From 17760023d21599ad474f0799cc9be49410454a94 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 19 Oct 2026 08:11:04 +0000 Subject: [PATCH] docs: translate the German locale Replace English copies under content/de with formal German and align terminology for Objektspeicher, pfadbasierte Adressierung, and the Console. Co-authored-by: hector --- content/de/administration/console/index.md | 64 ++-- content/de/administration/cors/index.md | 34 +-- .../de/administration/data/bucket/creation.md | 36 +-- .../de/administration/data/bucket/deletion.md | 44 +-- .../de/administration/data/bucket/meta.json | 4 +- .../de/administration/data/bucket/policy.md | 110 +++---- .../de/administration/data/bucket/quota.md | 130 ++++---- .../administration/data/bucket/replication.md | 242 +++++++-------- .../data/lifecycle-management.md | 68 ++--- .../de/administration/data/object/creation.md | 58 ++-- .../de/administration/data/object/deletion.md | 38 +-- .../data/object/multipart-upload.md | 106 +++---- .../administration/data/object/object-lock.md | 90 +++--- .../de/administration/data/object/scanner.md | 36 +-- .../administration/data/object/versioning.md | 106 +++---- .../de/administration/data/tiered-storage.md | 144 ++++----- content/de/administration/index.md | 20 +- content/de/administration/protocols/ftps.md | 180 +++++------ content/de/administration/protocols/s3.md | 144 ++++----- content/de/administration/protocols/sftp.md | 150 ++++----- content/de/administration/protocols/webdav.md | 134 ++++---- content/de/developer/examples/aws-cli.md | 28 +- content/de/developer/examples/aws-sdk-go.md | 18 +- content/de/developer/examples/aws-sdk-js.md | 18 +- content/de/developer/examples/boto3.md | 20 +- content/de/developer/examples/meta.json | 4 +- content/de/developer/examples/rclone.md | 24 +- content/de/developer/examples/s3cmd.md | 20 +- content/de/developer/examples/terraform.md | 14 +- content/de/developer/index.md | 16 +- content/de/developer/integration/ai/mlflow.md | 82 ++--- content/de/developer/integration/ai/ray.md | 51 ++-- content/de/developer/integration/ai/vllm.md | 70 +++-- .../de/developer/integration/backup/kopia.md | 53 ++-- .../developer/integration/backup/longhorn.md | 83 ++--- .../de/developer/integration/backup/velero.md | 68 +++-- .../developer/integration/big-data/airflow.md | 68 ++--- .../developer/integration/big-data/automq.md | 54 ++-- .../integration/big-data/delta-lake.md | 58 ++-- .../integration/big-data/dolphinscheduler.md | 54 ++-- .../developer/integration/big-data/flink.md | 8 +- .../de/developer/integration/big-data/hive.md | 58 ++-- .../de/developer/integration/big-data/hudi.md | 48 +-- .../developer/integration/big-data/kafka.md | 74 ++--- .../developer/integration/big-data/meta.json | 2 +- .../developer/integration/big-data/paimon.md | 48 +-- .../integration/big-data/pyiceberg.md | 6 +- .../integration/big-data/seatunnel.md | 50 +-- .../developer/integration/big-data/spark.md | 8 +- .../integration/big-data/zeppelin.md | 56 ++-- .../integration/cloud-native/celld.md | 62 ++-- .../integration/cloud-native/cortex.md | 62 ++-- .../integration/cloud-native/flux.md | 62 ++-- .../integration/cloud-native/index.md | 10 +- .../integration/cloud-native/meta.json | 2 +- .../integration/database/clickhouse.md | 60 ++-- .../integration/database/databend.md | 62 ++-- .../developer/integration/database/doris.md | 72 ++--- .../developer/integration/database/duckdb.md | 8 +- .../developer/integration/database/index.md | 10 +- .../integration/database/influxdb.md | 6 +- .../developer/integration/database/lancedb.md | 58 ++-- .../developer/integration/database/meta.json | 2 +- .../developer/integration/database/milvus.md | 108 +++---- .../developer/integration/database/trino.md | 10 +- .../developer/integration/database/vitess.md | 70 ++--- .../integration/devops/elasticsearch.md | 89 +++--- .../de/developer/integration/devops/gitea.md | 88 +++--- .../developer/integration/devops/jenkins.md | 78 ++--- .../integration/devops/opensearch.md | 77 ++--- .../developer/integration/devops/terraform.md | 72 ++--- .../integration/observability/fluentd.md | 62 ++-- .../integration/observability/greptimedb.md | 65 ++-- .../integration/observability/loki.md | 6 +- .../integration/observability/openobserve.md | 14 +- .../observability/opentelemetry.md | 61 ++-- .../integration/observability/tempo.md | 6 +- .../integration/observability/thanos.md | 88 +++--- .../observability/victoriametrics.md | 73 ++--- .../developer/integration/others/juicefs.md | 60 ++-- .../developer/integration/others/nextcloud.md | 60 ++-- .../de/developer/integration/others/rclone.md | 70 ++--- .../de/developer/integration/others/tusd.md | 70 ++--- .../integration/registry/docker-registry.md | 58 ++-- .../developer/integration/registry/harbor.md | 10 +- .../integration/reverse-proxy/caddy.md | 68 ++--- .../integration/reverse-proxy/envoy.md | 72 ++--- .../integration/reverse-proxy/haproxy.md | 76 ++--- .../integration/reverse-proxy/httpd.md | 158 +++++----- .../integration/reverse-proxy/index.md | 14 +- .../integration/reverse-proxy/meta.json | 2 +- .../integration/reverse-proxy/nginx.md | 72 ++--- .../integration/reverse-proxy/traefik.md | 68 ++--- .../developer/integration/storage/alluxio.md | 58 ++-- .../de/developer/integration/storage/index.md | 10 +- .../developer/integration/storage/lakefs.md | 60 ++-- .../developer/integration/storage/meta.json | 2 +- .../developer/integration/storage/opendal.md | 52 ++-- .../de/developer/integration/storage/s3fs.md | 54 ++-- .../developer/integration/storage/sftpgo.md | 54 ++-- .../developer/integration/storage/zerofs.md | 72 ++--- content/de/developer/license.md | 10 +- content/de/developer/mcp.md | 152 ++++----- content/de/developer/sdk/go.md | 48 +-- content/de/developer/sdk/index.md | 50 ++- content/de/developer/sdk/java.md | 102 +++---- content/de/developer/sdk/javascript.md | 78 ++--- content/de/developer/sdk/other.md | 68 ++--- content/de/developer/sdk/python.md | 100 +++--- content/de/developer/sdk/rust.md | 50 +-- content/de/developer/sdk/typescript.md | 42 +-- content/de/index.mdx | 4 +- .../cloud-native/helm-chart/cert-manager.md | 32 +- .../cloud-native/helm-chart/index.md | 24 +- .../cloud-native/helm-chart/installation.mdx | 84 ++--- .../cloud-native/helm-chart/mtls.md | 32 +- content/de/installation/cloud-native/index.md | 132 ++++---- .../de/installation/cloud-native/meta.json | 2 +- .../cloud-native/operator/index.md | 32 +- .../cloud-native/operator/installation.md | 52 ++-- .../installation/cloud-native/operator/kms.md | 36 +-- .../cloud-native/operator/pool-expansion.md | 24 +- .../cloud-native/operator/tenant.md | 28 +- content/de/installation/container/docker.md | 76 ++--- content/de/installation/container/index.md | 18 +- content/de/installation/container/podman.md | 36 +-- content/de/installation/index.md | 42 +-- content/de/installation/linux/index.md | 32 +- .../linux/multiple-node-multiple-disk.md | 60 ++-- .../linux/prerequisites-and-service.md | 2 + content/de/installation/linux/quick-start.md | 64 ++-- .../linux/single-node-multiple-disk.md | 46 +-- .../linux/single-node-single-disk.md | 44 +-- content/de/installation/macos/index.md | 210 ++++++------- .../checklists/hardware-checklists.md | 183 +++++------ .../checklists/hardware-selection.md | 60 ++-- .../requirement/checklists/index.md | 24 +- .../checklists/network-checklists.md | 108 +++---- .../checklists/security-checklists.md | 92 +++--- .../checklists/software-checklists.md | 68 ++--- .../requirement/disk-preparation.md | 48 +-- .../requirement/ec-configuration.md | 96 +++--- content/de/installation/windows/index.md | 176 +++++------ content/de/integration/tls-configured.md | 34 ++- content/de/integration/virtual.md | 51 ++-- content/de/operations/cluster-lifecycle.md | 246 +++++++-------- content/de/operations/credentials.md | 84 ++--- content/de/operations/event-notifications.md | 116 +++---- .../de/operations/high-availability/index.md | 8 +- .../high-availability/node-healing.md | 192 ++++++------ .../high-availability/site-replication.md | 158 +++++----- content/de/operations/index.md | 22 +- content/de/operations/observability.md | 240 +++++++-------- content/de/operations/rc.mdx | 66 ++-- .../de/operations/scaling/data-rebalancing.md | 70 ++--- content/de/operations/scaling/index.md | 10 +- .../scaling/storage-pool-decommission.md | 96 +++--- .../scaling/storage-pool-expansion.md | 86 +++--- content/de/operations/status-check.md | 92 +++--- content/de/operations/upgrade/binary/index.md | 26 +- .../de/operations/upgrade/container/index.md | 66 ++-- content/de/operations/upgrade/index.md | 14 +- .../de/operations/upgrade/kubernetes/index.md | 82 ++--- content/de/reference/cli.md | 108 +++---- content/de/reference/environment-variables.md | 288 +++++++++--------- content/de/reference/index.md | 12 +- content/de/security-compliance/audit-logs.md | 104 +++---- .../security-compliance/encryption/index.md | 16 +- .../de/security-compliance/encryption/kms.md | 102 ++++--- .../security-compliance/encryption/sse-c.md | 56 ++-- .../security-compliance/encryption/sse-s.md | 46 +-- .../security-compliance/iam/access-token.md | 36 +-- content/de/security-compliance/iam/index.md | 66 ++-- content/de/security-compliance/iam/sts.md | 90 +++--- content/de/security-compliance/index.md | 20 +- content/de/security-compliance/meta.json | 2 +- content/de/security-compliance/oidc/gitlab.md | 138 ++++----- content/de/security-compliance/oidc/index.md | 48 +-- content/de/troubleshooting/driver.md | 91 +++--- content/de/troubleshooting/index.md | 13 +- content/de/troubleshooting/node.md | 84 ++--- 181 files changed, 5777 insertions(+), 5731 deletions(-) diff --git a/content/de/administration/console/index.md b/content/de/administration/console/index.md index e8af749ff..9cde47022 100644 --- a/content/de/administration/console/index.md +++ b/content/de/administration/console/index.md @@ -1,13 +1,13 @@ --- title: "Console" -description: "Enable the RustFS Console, connect it to a server, and sign in securely." +description: "Aktivieren Sie die RustFS-Console, verbinden Sie sie mit einem Server und melden Sie sich sicher an." --- -The **RustFS Console** is the web administration interface for RustFS. Use this page to enable the Console, open the login page, and choose the appropriate sign-in method. Detailed procedures for buckets, objects, and identity management are covered in their respective documentation sections. +Die **RustFS Console** ist die Weboberfläche für die Administration von RustFS. Auf dieser Seite aktivieren Sie die Console, öffnen die Anmeldeseite und wählen das passende Anmeldeverfahren. Ausführliche Abläufe für Buckets, Objekte und die Identitätsverwaltung stehen in den jeweiligen Dokumentationsabschnitten. -## Enable the Console +## Console aktivieren -The Console is enabled by default and listens on port `9001`, separately from the S3 API on port `9000`. You can set the behavior explicitly with the following environment variables: +Die Console ist standardmäßig aktiviert und lauscht auf Port `9001`, getrennt von der S3-API auf Port `9000`. Das Verhalten legen Sie mit den folgenden Umgebungsvariablen ausdrücklich fest: ```ini title="/etc/default/rustfs" RUSTFS_ADDRESS=":9000" @@ -17,56 +17,56 @@ RUSTFS_OBS_LOGGER_LEVEL=error RUSTFS_OBS_LOG_DIRECTORY="/var/log/rustfs/" ``` -Restart RustFS after changing these values. Set `RUSTFS_CONSOLE_ENABLE=false` when the Console must not run. +Starten Sie RustFS neu, nachdem Sie diese Werte geändert haben. Setzen Sie `RUSTFS_CONSOLE_ENABLE=false`, wenn die Console nicht laufen darf. -The equivalent command-line options are `--console-enable` and `--console-address`. See the [CLI reference](/reference/cli) and [environment variable reference](/reference/environment-variables) for the complete server configuration. +Die entsprechenden Kommandozeilenoptionen sind `--console-enable` und `--console-address`. Die vollständige Serverkonfiguration finden Sie in der [CLI-Referenz](/de/reference/cli) und in der [Referenz der Umgebungsvariablen](/de/reference/environment-variables). -## Open the Console +## Console öffnen -Open the following address, replacing `` with the RustFS server address: +Öffnen Sie die folgende Adresse und ersetzen Sie `` durch die Adresse des RustFS-Servers: ```text http://:9001 ``` -![RustFS Console login page with key, STS, and OIDC sign-in options](./images/rustfs-console-login.png) +![Anmeldeseite der RustFS-Console mit den Anmeldeoptionen Schlüssel, STS und OIDC](./images/rustfs-console-login.png) -For a local deployment, use `http://localhost:9001`. Windows and macOS desktop launchers use port `7001` instead. +Für eine lokale Bereitstellung, einschließlich der Desktop-Starter für Windows und macOS, öffnen Sie `http://localhost:9001`. Die S3-API lauscht auf Port `9000`. -If the login page cannot reach the target RustFS service, select **Server Configuration** or open `/config`. Enter the externally reachable RustFS service address and save it after the health check succeeds. **Reset** clears the saved address; **Skip** returns to login without changing it. +Wenn die Anmeldeseite den Ziel-RustFS-Dienst nicht erreicht, wählen Sie **Server Configuration** (Serverkonfiguration) oder öffnen Sie `/config`. Geben Sie die von außen erreichbare Adresse des RustFS-Dienstes ein und speichern Sie sie, nachdem die Integritätsprüfung erfolgreich war. **Reset** (Zurücksetzen) löscht die gespeicherte Adresse. **Skip** (Überspringen) kehrt zur Anmeldung zurück, ohne sie zu ändern. -## Log in +## Anmelden -The login methods shown depend on the deployment configuration: +Welche Anmeldeverfahren angezeigt werden, hängt von der Konfiguration der Bereitstellung ab: -- **Key Login** uses the access key and secret key configured for the RustFS deployment. This is the standard login method for a local administrator. -- **STS Login** uses temporary Security Token Service (STS) credentials. Use it only when your identity workflow has issued a valid session token. -- **OIDC Login** appears when an OpenID Connect (OIDC) provider is configured. Select the provider and complete authentication with the identity provider. +- **Key Login** (Anmeldung mit Schlüssel) verwendet den Zugriffsschlüssel und den geheimen Zugriffsschlüssel der RustFS-Bereitstellung. Das ist das übliche Anmeldeverfahren für eine lokale Administration. +- **STS Login** (STS-Anmeldung) verwendet temporäre Zugangsdaten des Security Token Service (STS). Verwenden Sie es nur, wenn Ihr Identitätsablauf ein gültiges Sitzungstoken ausgestellt hat. +- **OIDC Login** (OIDC-Anmeldung) erscheint, wenn ein OpenID-Connect-Anbieter (OIDC) konfiguriert ist. Wählen Sie den Anbieter und schließen Sie die Authentifizierung beim Identitätsanbieter ab. -After login, the Console opens the first page your account can access. Menus and actions vary by account policy and enabled platform capabilities; a missing menu does not necessarily indicate a Console error. +Nach der Anmeldung öffnet die Console die erste Seite, auf die Ihr Konto zugreifen kann. Menüs und Aktionen hängen von der Kontorichtlinie und den aktivierten Plattformfunktionen ab. Ein fehlendes Menü weist nicht zwangsläufig auf einen Fehler der Console hin. -If login fails, verify the selected login method, credentials, target server address, and account status before retrying. +Wenn die Anmeldung fehlschlägt, prüfen Sie das gewählte Anmeldeverfahren, die Anmeldedaten, die Zielserveradresse und den Kontostatus, bevor Sie es erneut versuchen. -:::warning[Do not expose default credentials] +:::warning[Standard-Anmeldedaten nicht offenlegen] -RustFS falls back to `rustfsadmin` / `rustfsadmin` when custom credentials are not configured. Use these defaults only for a throwaway local test. Configure a unique access key and a strong secret key before making the Console reachable by other users. +RustFS fällt auf `rustfsadmin` / `rustfsadmin` zurück, wenn keine eigenen Anmeldedaten konfiguriert sind. Verwenden Sie diese Standardwerte nur für einen lokalen Test, den Sie anschließend verwerfen. Konfigurieren Sie einen eindeutigen Zugriffsschlüssel und einen starken geheimen Zugriffsschlüssel, bevor andere Benutzer die Console erreichen können. ::: -## Operational notes +## Betriebshinweise -- Use [TLS](/integration/tls-configured) before exposing the Console outside a trusted network. -- Restrict network access to the Console listener and configure [Console CORS](/administration/cors) only when cross-origin access is required. -- The Console session inherits the permissions of the signed-in identity. Use a least-privilege account for routine work. -- Signing out or an expired session returns you to the login page. Do not store administrator credentials in shared browsers. +- Verwenden Sie [TLS](/de/integration/tls-configured), bevor Sie die Console außerhalb eines vertrauenswürdigen Netzwerks erreichbar machen. +- Beschränken Sie den Netzwerkzugriff auf den Console-Listener und konfigurieren Sie [CORS der Console](/de/administration/cors) nur, wenn ursprungsübergreifender Zugriff erforderlich ist. +- Die Console-Sitzung übernimmt die Berechtigungen der angemeldeten Identität. Verwenden Sie für die tägliche Arbeit ein Konto mit minimalen Rechten. +- Abmelden oder eine abgelaufene Sitzung führt Sie zur Anmeldeseite zurück. Speichern Sie Administrator-Anmeldedaten nicht in gemeinsam genutzten Browsern. -## Management workflows +## Verwaltungsabläufe -- [Create and manage buckets](/administration/data/bucket/creation) -- [Upload and manage objects](/administration/data/object/creation) -- [Manage access keys](/security-compliance/iam/access-token) -- [Configure identity and access management](/security-compliance/iam) +- [Buckets erstellen und verwalten](/de/administration/data/bucket/creation) +- [Objekte hochladen und verwalten](/de/administration/data/object/creation) +- [Zugriffsschlüssel verwalten](/de/security-compliance/iam/access-token) +- [Identitäts- und Zugriffsverwaltung konfigurieren](/de/security-compliance/iam) -## Next steps +## Nächste Schritte -Review the [security checklist](/installation/requirement/checklists/security-checklists) before exposing the Console outside a trusted network. For OIDC-based login, continue with the [OIDC configuration guide](/security-compliance/oidc). +Prüfen Sie die [Sicherheitscheckliste](/de/installation/requirement/checklists/security-checklists), bevor Sie die Console außerhalb eines vertrauenswürdigen Netzwerks erreichbar machen. Für die Anmeldung über OIDC fahren Sie mit der [OIDC-Konfiguration](/de/security-compliance/oidc) fort. diff --git a/content/de/administration/cors/index.md b/content/de/administration/cors/index.md index d4e52db44..5c8334174 100644 --- a/content/de/administration/cors/index.md +++ b/content/de/administration/cors/index.md @@ -1,41 +1,41 @@ --- -title: "CORS Configuration" -description: "Configure allowed browser origins for the RustFS S3 API and Console." +title: "CORS-Konfiguration" +description: "Konfigurieren Sie die zulässigen Browser-Origins für die S3-API und die Console von RustFS." --- -Cross-Origin Resource Sharing (CORS) controls which browser origins can access the RustFS S3 API and Console. Configure each listener separately, then restart RustFS to apply the environment changes. +Cross-Origin Resource Sharing (CORS) steuert, welche Browser-Origins auf die S3-API und die Console von RustFS zugreifen dürfen. Konfigurieren Sie jeden Listener getrennt und starten Sie RustFS neu, damit die Änderungen an den Umgebungsvariablen wirksam werden. -## S3 API origins +## Origins der S3-API -Set `RUSTFS_CORS_ALLOWED_ORIGINS` to a comma-separated list of trusted origins: +Setzen Sie `RUSTFS_CORS_ALLOWED_ORIGINS` auf eine durch Kommas getrennte Liste vertrauenswürdiger Origins: ```ini title="/etc/default/rustfs" RUSTFS_CORS_ALLOWED_ORIGINS="https://app.example.com,https://admin.example.com" ``` -When this variable is unset or empty, the S3 endpoint does not add generic CORS response headers. A list of explicit origins allows credentialed browser requests from matching origins. +Wenn diese Variable nicht gesetzt oder leer ist, fügt der S3-Endpunkt keine allgemeinen CORS-Antwortheader hinzu. Eine Liste ausdrücklicher Origins erlaubt Browseranfragen mit Zugangsdaten von übereinstimmenden Origins. -You can set the value to `*` to allow requests from any origin. Wildcard mode does not allow browser credentials. +Sie können den Wert auf `*` setzen, um Anfragen von jeder Origin zuzulassen. Der Wildcard-Modus lässt keine Browser-Zugangsdaten zu. -:::warning[Use explicit origins in production] +:::warning[In der Produktion ausdrückliche Origins verwenden] -Use a comma-separated allowlist for applications that send credentials. Reserve `*` for public resources that do not require credentialed browser requests. +Verwenden Sie eine durch Kommas getrennte Zulassungsliste für Anwendungen, die Zugangsdaten senden. Reservieren Sie `*` für öffentliche Ressourcen, die keine Browseranfragen mit Zugangsdaten erfordern. ::: -## Console origins +## Origins der Console -The Console uses a separate variable: +Die Console verwendet eine eigene Variable: ```ini title="/etc/default/rustfs" RUSTFS_CONSOLE_CORS_ALLOWED_ORIGINS="https://admin.example.com" ``` -Use a comma-separated list when more than one browser origin must access the Console. Set `*` only when any origin must be allowed. +Verwenden Sie eine durch Kommas getrennte Liste, wenn mehr als eine Browser-Origin auf die Console zugreifen muss. Setzen Sie `*` nur, wenn jede Origin zugelassen werden soll. -## Verify the response +## Antwort prüfen -Send a request with an `Origin` header and inspect the CORS response headers: +Senden Sie eine Anfrage mit einem `Origin`-Header und prüfen Sie die CORS-Antwortheader: ```bash curl -i \ @@ -43,8 +43,8 @@ curl -i \ http://localhost:9000/ ``` -Confirm that `Access-Control-Allow-Origin` contains the expected origin. Repeat the check with an unlisted origin and confirm that it is not allowed. +Prüfen Sie, dass `Access-Control-Allow-Origin` die erwartete Origin enthält. Wiederholen Sie die Prüfung mit einer nicht aufgeführten Origin und bestätigen Sie, dass sie nicht zugelassen wird. -## Next steps +## Nächste Schritte -See the [environment variable reference](/reference/environment-variables#cors) for the verified defaults and configuration formats. \ No newline at end of file +Die geprüften Standardwerte und Konfigurationsformate stehen in der [Referenz der Umgebungsvariablen](/de/reference/environment-variables#cors). diff --git a/content/de/administration/data/bucket/creation.md b/content/de/administration/data/bucket/creation.md index 46804ffcf..623a919ab 100644 --- a/content/de/administration/data/bucket/creation.md +++ b/content/de/administration/data/bucket/creation.md @@ -1,28 +1,28 @@ --- -title: "RustFS Bucket Creation" -description: "Create buckets using the RustFS UI, rc, or the S3 API." +title: "Bucket erstellen" +description: "Erstellen Sie Buckets über die RustFS-Oberfläche, mit rc oder über die S3-API." --- -This guide explains how to create buckets using the RustFS UI, `rc`, or the S3 API. +In dieser Anleitung erstellen Sie Buckets über die RustFS-Console, mit `rc` oder über die S3-API. -## Requirements +## Voraussetzungen -- A running RustFS instance (see [Installation Guide](../../../installation/index.md)). -- [`rc`](/operations/rc) installed and configured with an alias for the command-line workflow. +- Eine laufende RustFS-Instanz (siehe [Installationsanleitung](../../../installation/index.md)). +- [`rc`](/de/operations/rc), installiert und mit einem Alias für den Kommandozeilenablauf konfiguriert. -## Using the RustFS UI +## RustFS-Console verwenden -1. Log in to the RustFS Console. -2. On the Buckets page, in the top right corner, select **Create Bucket**. -3. Enter the bucket name and click **Create** to complete bucket creation. +1. Melden Sie sich an der RustFS-Console an. +2. Wählen Sie auf der Seite **Buckets** oben rechts **Create Bucket** (Bucket erstellen). +3. Geben Sie einen Bucket-Namen ein und wählen Sie **Create** (Erstellen). -![bucket creation](images/bucket-creation-by-ui.png) +![Bucket-Erstellung](images/bucket-creation-by-ui.png) -## Using `rc` +## `rc` verwenden -See the [`rc` guide](/operations/rc) for installation and alias configuration. +Installation und Alias-Konfiguration stehen in der [`rc`-Anleitung](/de/operations/rc). -Create a bucket: +Erstellen Sie einen Bucket: ```bash rc bucket create rustfs/my-bucket @@ -33,15 +33,15 @@ rc bucket list rustfs/ ✓ Bucket 'rustfs/my-bucket' created successfully. ``` -## Using the API +## API verwenden -Create a bucket via API: +Erstellen Sie einen Bucket über die API: ```http PUT /{bucketName} HTTP/1.1 ``` -S3 requests must be signed with AWS Signature V4, so use an S3 client rather than hand-crafting headers. With the [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) configured for your access keys: +S3-Anfragen müssen mit AWS Signature V4 signiert sein. Verwenden Sie deshalb einen S3-Client, anstatt Header von Hand zu setzen. Mit der für Ihre Zugriffsschlüssel konfigurierten [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html): ```bash aws s3api create-bucket \ @@ -49,4 +49,4 @@ aws s3api create-bucket \ --endpoint-url http://localhost:9000 ``` -Verify the bucket creation in the RustFS Console. +Prüfen Sie in der RustFS-Console, dass der Bucket angezeigt wird. diff --git a/content/de/administration/data/bucket/deletion.md b/content/de/administration/data/bucket/deletion.md index b2234a810..93a4e9973 100644 --- a/content/de/administration/data/bucket/deletion.md +++ b/content/de/administration/data/bucket/deletion.md @@ -1,31 +1,35 @@ --- -title: "RustFS Bucket Deletion" -description: "Delete buckets using the RustFS UI, rc, or the S3 API." +title: "Bucket löschen" +description: "Löschen Sie Buckets über die RustFS-Oberfläche, mit rc oder über die S3-API." --- -This guide explains how to delete buckets using the RustFS UI, `rc`, or the S3 API. +In dieser Anleitung löschen Sie Buckets über die RustFS-Oberfläche, mit `rc` oder über die S3-API. -## Requirements +## Voraussetzungen -- Install and configure [`rc`](/operations/rc) before using the command-line workflow. -- Empty the target bucket before deleting it, or use `--force` only after reviewing the objects that will be removed. +- Installieren und konfigurieren Sie [`rc`](/de/operations/rc), bevor Sie den Kommandozeilenablauf verwenden. +- Leeren Sie den Ziel-Bucket, bevor Sie ihn löschen, oder verwenden Sie `--force` erst, nachdem Sie die Objekte geprüft haben, die entfernt werden. -**Warning**: Deleting a bucket is irreversible and may break applications relying on it. Ensure you have backed up any necessary data before proceeding. +:::warning[Das Löschen ist endgültig] -## Using the RustFS UI +Das Löschen eines Buckets lässt sich nicht rückgängig machen und kann Anwendungen beeinträchtigen, die davon abhängen. Sichern Sie alle Daten, die Sie behalten müssen, bevor Sie fortfahren. -1. Log in to the RustFS Console. -2. On the homepage, select the bucket you want to delete. -3. On the far right, select the **Delete** button. -4. In the popup dialog, click **Confirm** to complete bucket deletion. +::: -![bucket deletion](images/bucket-deletion-on-ui.png) +## RustFS-Oberfläche verwenden -## Using `rc` +1. Melden Sie sich an der RustFS-Console an. +2. Wählen Sie auf der Startseite den Bucket, den Sie löschen möchten. +3. Wählen Sie ganz rechts die Schaltfläche **Delete** (Löschen). +4. Wählen Sie im Bestätigungsdialog **Confirm** (Bestätigen). -See the [`rc` guide](/operations/rc) for installation and alias configuration. +![Bucket-Löschung](images/bucket-deletion-on-ui.png) -Delete a bucket: +## `rc` verwenden + +Installation und Alias-Konfiguration stehen in der [`rc`-Anleitung](/de/operations/rc). + +Löschen Sie einen Bucket: ```bash rc bucket remove rustfs/my-bucket @@ -35,15 +39,15 @@ rc bucket remove rustfs/my-bucket ✓ Bucket 'rustfs/my-bucket' removed successfully. ``` -## Using the API +## API verwenden -Delete a bucket via API: +Löschen Sie einen Bucket über die API: ```http DELETE /{bucketName} HTTP/1.1 ``` -S3 requests must be signed with AWS Signature V4, so use an S3 client rather than hand-crafting headers. With the [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) configured for your access keys: +S3-Anfragen müssen mit AWS Signature V4 signiert sein. Verwenden Sie deshalb einen S3-Client, anstatt Header von Hand zu setzen. Mit der für Ihre Zugriffsschlüssel konfigurierten [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html): ```bash aws s3api delete-bucket \ @@ -51,4 +55,4 @@ aws s3api delete-bucket \ --endpoint-url http://localhost:9000 ``` -Verify the bucket deletion in the RustFS Console. +Prüfen Sie die Löschung des Buckets in der RustFS-Console. diff --git a/content/de/administration/data/bucket/meta.json b/content/de/administration/data/bucket/meta.json index 48d5e82b2..bcd7c6cc0 100644 --- a/content/de/administration/data/bucket/meta.json +++ b/content/de/administration/data/bucket/meta.json @@ -1,5 +1,5 @@ { - "title": "Buckets", + "title": "Bucket", "pages": [ "creation", "deletion", @@ -7,4 +7,4 @@ "replication", "policy" ] -} \ No newline at end of file +} diff --git a/content/de/administration/data/bucket/policy.md b/content/de/administration/data/bucket/policy.md index c13c11b50..9c670656f 100644 --- a/content/de/administration/data/bucket/policy.md +++ b/content/de/administration/data/bucket/policy.md @@ -1,58 +1,58 @@ --- -title: "Bucket Policy" -description: "Create, apply, inspect, and verify RustFS bucket policies with the S3 API." +title: "Bucket-Richtlinie" +description: "Erstellen, anwenden, lesen und prüfen Sie Bucket-Richtlinien von RustFS über die S3-API." --- -RustFS bucket policies are S3-compatible resource policies attached directly to a bucket. Use them to grant or deny access to the bucket and its objects, including controlled anonymous access for public downloads. +Bucket-Richtlinien von RustFS sind S3-kompatible Ressourcenrichtlinien, die direkt an einen Bucket gebunden sind. Damit gewähren oder verweigern Sie den Zugriff auf den Bucket und seine Objekte, einschließlich eines kontrollierten anonymen Zugriffs für öffentliche Downloads. -## Overview +## Überblick -A bucket policy contains one or more statements that match a principal, action, resource, and optional conditions. RustFS evaluates the policy for requests to the bucket before allowing the storage operation. +Eine Bucket-Richtlinie enthält eine oder mehrere Anweisungen, die einen Principal, eine Aktion, eine Ressource und optionale Bedingungen abgleichen. RustFS wertet die Richtlinie für Anfragen an den Bucket aus, bevor es die Speicheroperation zulässt. -Bucket policies and IAM policies serve different purposes: +Bucket-Richtlinien und IAM-Richtlinien erfüllen unterschiedliche Zwecke: -| Policy type | Attached to | Typical use | +| Richtlinientyp | Gebunden an | Typische Verwendung | | --- | --- | --- | -| Bucket policy | A bucket | Grant public access, add resource-level restrictions, or authorize access to one bucket. | -| IAM policy | A user or group | Define what an authenticated identity can do across one or more resources. | +| Bucket-Richtlinie | Einen Bucket | Öffentlichen Zugriff gewähren, Einschränkungen auf Ressourcenebene hinzufügen oder den Zugriff auf einen Bucket autorisieren. | +| IAM-Richtlinie | Einen Benutzer oder eine Gruppe | Festlegen, was eine authentifizierte Identität über eine oder mehrere Ressourcen tun darf. | -An explicit `Deny` takes precedence over an `Allow`. Bucket owners remain able to get, replace, or delete the bucket policy so that a deny statement cannot permanently lock policy administration. +Ein ausdrückliches `Deny` hat Vorrang vor einem `Allow`. Bucket-Eigentümer können die Bucket-Richtlinie weiterhin abrufen, ersetzen oder löschen, damit eine Deny-Anweisung die Richtlinienverwaltung nicht dauerhaft sperrt. -RustFS implements the standard S3 operations `PutBucketPolicy`, `GetBucketPolicy`, `GetBucketPolicyStatus`, and `DeleteBucketPolicy`. +RustFS implementiert die Standard-S3-Operationen `PutBucketPolicy`, `GetBucketPolicy`, `GetBucketPolicyStatus` und `DeleteBucketPolicy`. -:::warning[Public policies] +:::warning[Öffentliche Richtlinien] -A statement with `"Principal": "*"` can grant access without authentication. Keep the action and resource scope as narrow as possible, and verify the result anonymously before using the policy in production. +Eine Anweisung mit `"Principal": "*"` kann Zugriff ohne Authentifizierung gewähren. Halten Sie den Umfang von Aktion und Ressource so eng wie möglich und prüfen Sie das Ergebnis anonym, bevor Sie die Richtlinie in der Produktion verwenden. ::: -## Configuration +## Konfiguration -### Requirements +### Voraussetzungen -- Create the target bucket before applying a policy. -- Configure the AWS CLI with a RustFS credential and region `us-east-1`. -- Use a credential allowed to perform the required policy-management action. +- Erstellen Sie den Ziel-Bucket, bevor Sie eine Richtlinie anwenden. +- Konfigurieren Sie die AWS CLI mit RustFS-Zugangsdaten und der Region `us-east-1`. +- Verwenden Sie Zugangsdaten, die die erforderliche Aktion zur Richtlinienverwaltung ausführen dürfen. -Set reusable variables: +Setzen Sie wiederverwendbare Variablen: ```bash export RUSTFS_ENDPOINT=http://localhost:9000 export BUCKET_NAME=my-bucket ``` -Policy management requires these actions: +Die Richtlinienverwaltung erfordert diese Aktionen: -| Operation | Required action | +| Operation | Erforderliche Aktion | | --- | --- | -| Apply or replace a policy | `s3:PutBucketPolicy` | -| Read a policy | `s3:GetBucketPolicy` | -| Read public status | `s3:GetBucketPolicyStatus` | -| Remove a policy | `s3:DeleteBucketPolicy` | +| Richtlinie anwenden oder ersetzen | `s3:PutBucketPolicy` | +| Richtlinie lesen | `s3:GetBucketPolicy` | +| Öffentlichen Status lesen | `s3:GetBucketPolicyStatus` | +| Richtlinie entfernen | `s3:DeleteBucketPolicy` | -### Policy document structure +### Aufbau des Richtliniendokuments -A bucket policy uses version `2012-10-17` and a `Statement` array: +Eine Bucket-Richtlinie verwendet die Version `2012-10-17` und ein `Statement`-Array: ```json { @@ -69,26 +69,26 @@ A bucket policy uses version `2012-10-17` and a `Statement` array: } ``` -The bucket ARN and object ARN are different: +Die Bucket-ARN und die Objekt-ARN unterscheiden sich: -| Resource | ARN format | Example actions | +| Ressource | ARN-Format | Beispielaktionen | | --- | --- | --- | | Bucket | `arn:aws:s3:::my-bucket` | `s3:ListBucket`, `s3:GetBucketLocation` | -| Objects | `arn:aws:s3:::my-bucket/*` | `s3:GetObject`, `s3:PutObject`, `s3:DeleteObject` | +| Objekte | `arn:aws:s3:::my-bucket/*` | `s3:GetObject`, `s3:PutObject`, `s3:DeleteObject` | -Use a prefix in the object ARN, such as `arn:aws:s3:::my-bucket/public/*`, to limit access to part of the bucket. For the complete statement format and supported condition operators, see [Users, Groups, and Policies](/security-compliance/iam/policies#policy-document-format). +Verwenden Sie ein Präfix in der Objekt-ARN, etwa `arn:aws:s3:::my-bucket/public/*`, um den Zugriff auf einen Teil des Buckets zu beschränken. Das vollständige Anweisungsformat und die unterstützten Bedingungsoperatoren stehen unter [Benutzer, Gruppen und Richtlinien](/de/security-compliance/iam/policies#policy-document-format). ### Public Access Block -If the bucket's Public Access Block configuration has `BlockPublicPolicy` enabled, RustFS rejects a new policy containing an `Allow` statement with a wildcard principal. Keep this protection enabled unless anonymous access is intentional. +Wenn `BlockPublicPolicy` in der Konfiguration Public Access Block (Sperre für öffentlichen Zugriff) des Buckets aktiviert ist, lehnt RustFS eine neue Richtlinie ab, die eine `Allow`-Anweisung mit einem Wildcard-Principal enthält. Lassen Sie diesen Schutz aktiviert, solange anonymer Zugriff nicht beabsichtigt ist. -Public Access Block does not replace careful policy review. An existing explicit `Deny` still overrides allows, and authenticated requests continue to be evaluated against IAM and bucket policies. +Public Access Block ersetzt keine sorgfältige Prüfung der Richtlinie. Ein vorhandenes ausdrückliches `Deny` setzt Allows weiterhin außer Kraft, und authentifizierte Anfragen werden weiterhin gegen IAM- und Bucket-Richtlinien geprüft. -## Usage +## Verwendung -### Create a public-read policy +### Richtlinie für öffentliches Lesen erstellen -Create a policy that allows anonymous downloads only from the `public/` prefix: +Erstellen Sie eine Richtlinie, die anonyme Downloads nur aus dem Präfix `public/` erlaubt: ```bash cat > /tmp/my-bucket-policy.json <<'EOF' @@ -107,9 +107,9 @@ cat > /tmp/my-bucket-policy.json <<'EOF' EOF ``` -This policy does not allow anonymous bucket listing, uploads, overwrites, or deletes. +Diese Richtlinie erlaubt kein anonymes Auflisten des Buckets, keine Uploads, keine Überschreibungen und keine Löschungen. -### Apply the policy +### Richtlinie anwenden ```bash aws s3api put-bucket-policy \ @@ -118,9 +118,9 @@ aws s3api put-bucket-policy \ --endpoint-url "$RUSTFS_ENDPOINT" ``` -Applying another policy replaces the complete existing policy. Retrieve and review the current document before updating it; statements are not merged automatically. +Eine weitere Richtlinie ersetzt die bestehende Richtlinie vollständig. Rufen Sie das aktuelle Dokument ab und prüfen Sie es, bevor Sie es aktualisieren. Anweisungen werden nicht automatisch zusammengeführt. -### Read the policy +### Richtlinie lesen ```bash aws s3api get-bucket-policy \ @@ -130,9 +130,9 @@ aws s3api get-bucket-policy \ --output text ``` -RustFS preserves the submitted policy JSON. If no policy exists, the API returns `NoSuchBucketPolicy`. +RustFS behält das übermittelte Richtlinien-JSON bei. Wenn keine Richtlinie vorhanden ist, gibt die API `NoSuchBucketPolicy` zurück. -### Check public status +### Öffentlichen Status prüfen ```bash aws s3api get-bucket-policy-status \ @@ -140,7 +140,7 @@ aws s3api get-bucket-policy-status \ --endpoint-url "$RUSTFS_ENDPOINT" ``` -The response contains a high-level public-access status: +Die Antwort enthält einen groben Status zum öffentlichen Zugriff: ```json { @@ -150,9 +150,9 @@ The response contains a high-level public-access status: } ``` -The current status check detects anonymous bucket listing (`s3:ListBucket`) and uploads (`s3:PutObject`). A policy that exposes only object downloads, such as the `public/` example above, can still report `false`. Always test the exact anonymous action, object prefix, and conditions instead of treating this status as a complete access analysis. +Die aktuelle Statusprüfung erkennt anonymes Auflisten des Buckets (`s3:ListBucket`) und Uploads (`s3:PutObject`). Eine Richtlinie, die nur Objekt-Downloads freigibt, wie das Beispiel `public/` oben, kann weiterhin `false` melden. Prüfen Sie immer die genaue anonyme Aktion, das Objektpräfix und die Bedingungen, anstatt diesen Status als vollständige Zugriffsanalyse zu behandeln. -### Remove the policy +### Richtlinie entfernen ```bash aws s3api delete-bucket-policy \ @@ -160,11 +160,11 @@ aws s3api delete-bucket-policy \ --endpoint-url "$RUSTFS_ENDPOINT" ``` -Deleting a bucket policy removes only that resource policy. IAM policies attached to users and groups remain unchanged. +Das Löschen einer Bucket-Richtlinie entfernt nur diese Ressourcenrichtlinie. IAM-Richtlinien, die an Benutzer und Gruppen gebunden sind, bleiben unverändert. -## Verification +## Überprüfung -Upload a test object with an authenticated credential: +Laden Sie ein Testobjekt mit authentifizierten Zugangsdaten hoch: ```bash printf 'hello from RustFS\n' > /tmp/hello.txt @@ -176,14 +176,14 @@ aws s3api put-object \ --endpoint-url "$RUSTFS_ENDPOINT" ``` -Verify that the allowed object can be downloaded without credentials: +Prüfen Sie, dass das zugelassene Objekt ohne Zugangsdaten heruntergeladen werden kann: ```bash curl --fail-with-body \ "${RUSTFS_ENDPOINT}/${BUCKET_NAME}/public/hello.txt" ``` -Then verify that an object outside the allowed prefix is not public: +Prüfen Sie anschließend, dass ein Objekt außerhalb des zugelassenen Präfixes nicht öffentlich ist: ```bash aws s3api put-object \ @@ -196,10 +196,10 @@ curl --fail-with-body \ "${RUSTFS_ENDPOINT}/${BUCKET_NAME}/private/hello.txt" ``` -The second `curl` request should fail with `AccessDenied`. Also test each authenticated user role that relies on the policy, especially when the document contains conditions or explicit deny statements. +Die zweite `curl`-Anfrage sollte mit `AccessDenied` fehlschlagen. Prüfen Sie außerdem jede authentifizierte Benutzerrolle, die sich auf die Richtlinie stützt, besonders wenn das Dokument Bedingungen oder ausdrückliche Deny-Anweisungen enthält. -## Next steps +## Nächste Schritte -- [Manage IAM policies](/security-compliance/iam/policies) -- [Manage credentials](/operations/credentials) -- [Configure audit logs](/security-compliance/audit-logs) \ No newline at end of file +- [IAM-Richtlinien verwalten](/de/security-compliance/iam/policies) +- [Zugangsdaten verwalten](/de/operations/credentials) +- [Audit-Protokolle konfigurieren](/de/security-compliance/audit-logs) diff --git a/content/de/administration/data/bucket/quota.md b/content/de/administration/data/bucket/quota.md index ef975aac0..71d20ca25 100644 --- a/content/de/administration/data/bucket/quota.md +++ b/content/de/administration/data/bucket/quota.md @@ -1,47 +1,47 @@ --- -title: "Bucket Quota" -description: "Configure, inspect, and verify hard storage quotas for individual RustFS buckets." +title: "Bucket-Kontingent" +description: "Konfigurieren, lesen und prüfen Sie harte Speicherkontingente für einzelne RustFS-Buckets." --- -RustFS bucket quotas limit the total object data stored in an individual bucket. Use a quota to prevent one workload from consuming more than its assigned capacity while allowing other buckets to use the remaining storage. +Bucket-Kontingente von RustFS begrenzen die gesamten Objektdaten, die in einem einzelnen Bucket gespeichert sind. Verwenden Sie ein Kontingent, damit ein Workload nicht mehr als die zugewiesene Kapazität verbraucht, während andere Buckets den übrigen Speicher nutzen können. -## Overview +## Überblick -RustFS currently supports hard, byte-based quotas. Before accepting a write, RustFS compares the bucket's current usage plus the requested object size with the configured limit. A write that would exceed the limit is rejected with `InvalidRequest` and a `Bucket quota exceeded` message. +RustFS unterstützt derzeit harte, bytebasierte Kontingente. Bevor RustFS einen Schreibvorgang annimmt, vergleicht es die aktuelle Nutzung des Buckets zuzüglich der angeforderten Objektgröße mit dem konfigurierten Limit. Ein Schreibvorgang, der das Limit überschreiten würde, wird mit `InvalidRequest` und der Meldung `Bucket quota exceeded` abgelehnt. -Quota checks cover these operations: +Kontingentprüfungen umfassen diese Operationen: -| Operation | Quota behavior | +| Operation | Kontingentverhalten | | --- | --- | -| Upload an object | Rejects the upload when current usage plus the object size exceeds the limit. | -| Complete a multipart upload | Checks the completed object size before committing the upload. | -| Copy an object into the bucket | Checks the source object size against the destination bucket quota. | -| Delete an object | Always allowed so that you can recover capacity. | +| Objekt hochladen | Lehnt den Upload ab, wenn die aktuelle Nutzung zuzüglich der Objektgröße das Limit überschreitet. | +| Mehrteiligen Upload abschließen | Prüft die Größe des abgeschlossenen Objekts, bevor der Upload festgeschrieben wird. | +| Objekt in den Bucket kopieren | Prüft die Größe des Quellobjekts gegen das Kontingent des Ziel-Buckets. | +| Objekt löschen | Immer zulässig, damit Sie Kapazität zurückgewinnen können. | -The quota applies to object data, not the number of objects or request rate. A bucket without a configured limit is unlimited. +Das Kontingent gilt für Objektdaten, nicht für die Anzahl der Objekte oder die Anfragerate. Ein Bucket ohne konfiguriertes Limit ist unbegrenzt. -:::note[Replacement uploads] +:::note[Ersetzende Uploads] -The quota check reserves the full incoming object size against the bucket's current usage. Replacing an existing key can therefore require enough headroom for the complete replacement object. +Die Kontingentprüfung reserviert die vollständige Größe des eingehenden Objekts gegen die aktuelle Nutzung des Buckets. Das Ersetzen eines vorhandenen Objektschlüssels kann deshalb genug freien Kontingentraum für das vollständige Ersatzobjekt erfordern. ::: -## Configure in the Console +## In der Console konfigurieren -1. Sign in to the RustFS Console and open **Browser**. -2. Find the bucket and select **Settings**. -3. Under **Capacity & Metadata**, find **Bucket Quota** and select **Edit**. -4. Enable **Bucket Quota**. -5. Enter the quota size and select **MiB**, **GiB**, **TiB**, or **PiB**. -6. Select **Save Quota**. +1. Melden Sie sich an der RustFS-Console an und öffnen Sie **Browser**. +2. Suchen Sie den Bucket und wählen Sie **Settings** (Einstellungen). +3. Suchen Sie unter **Capacity & Metadata** (Kapazität und Metadaten) den Eintrag **Bucket Quota** (Bucket-Kontingent) und wählen Sie **Edit** (Bearbeiten). +4. Aktivieren Sie **Bucket Quota**. +5. Geben Sie die Kontingentgröße ein und wählen Sie **MiB**, **GiB**, **TiB** oder **PiB**. +6. Wählen Sie **Save Quota** (Kontingent speichern). -![Set Bucket Quota dialog with quota size and unit controls](./images/bucket-quota-console.png) +![Dialog zum Festlegen des Bucket-Kontingents mit Größe und Einheit](./images/bucket-quota-console.png) -To remove the limit, open the dialog again, disable **Bucket Quota**, and save the change. +Um das Limit zu entfernen, öffnen Sie den Dialog erneut, deaktivieren Sie **Bucket Quota** und speichern Sie die Änderung. -## Use rc +## `rc` verwenden -Configure an alias for your RustFS deployment: +Konfigurieren Sie einen Alias für Ihre RustFS-Bereitstellung: ```bash rc alias set rustfs http://localhost:9000 \ @@ -49,29 +49,29 @@ rc alias set rustfs http://localhost:9000 \ --region us-east-1 --bucket-lookup path ``` -Replace `localhost` with the RustFS server address when `rc` runs on another host. +Ersetzen Sie `localhost` durch die Adresse des RustFS-Servers, wenn `rc` auf einem anderen Host läuft. -### Permissions +### Berechtigungen -Quota operations require these policy actions: +Kontingentoperationen erfordern diese Richtlinienaktionen: -| Operation | Required action | +| Operation | Erforderliche Aktion | | --- | --- | -| Set or clear a quota | `admin:SetBucketQuota` | -| Read quota configuration or statistics | `s3:GetBucketQuota` | -| Check whether a proposed operation fits | `s3:GetBucketQuota` | +| Kontingent setzen oder löschen | `admin:SetBucketQuota` | +| Kontingentkonfiguration oder Statistik lesen | `s3:GetBucketQuota` | +| Prüfen, ob eine geplante Operation passt | `s3:GetBucketQuota` | -The root credential has these permissions. For delegated administration, attach only the actions needed for the workflow. +Die Root-Anmeldedaten besitzen diese Berechtigungen. Hängen Sie für die delegierte Administration nur die Aktionen an, die der Ablauf benötigt. -### Set a quota +### Kontingent setzen -Set a 1 GiB hard quota. `rc` accepts byte values or units such as `1G`, `500M`, and `10KB`: +Setzen Sie ein hartes Kontingent von 1 GiB. `rc` akzeptiert Bytewerte oder Einheiten wie `1G`, `500M` und `10KB`: ```bash rc bucket quota set rustfs/my-bucket 1G ``` -The response includes the configured limit and current usage: +Die Antwort enthält das konfigurierte Limit und die aktuelle Nutzung: ```text Bucket: my-bucket @@ -80,42 +80,42 @@ Usage: 0 B Type: HARD ``` -### Read the quota +### Kontingent lesen ```bash rc bucket quota info rustfs/my-bucket ``` -Use `--json` when another tool needs to process the result: +Verwenden Sie `--json`, wenn ein anderes Werkzeug das Ergebnis verarbeiten muss: ```bash rc bucket quota info rustfs/my-bucket --json ``` -When no limit is configured, the human-readable output reports `Quota: unlimited`. +Wenn kein Limit konfiguriert ist, meldet die lesbare Ausgabe `Quota: unlimited`. -:::note[Configuration propagation] +:::note[Weitergabe der Konfiguration] -A query issued immediately after setting or clearing a quota can briefly return the previous state. Query the quota again and confirm the expected value before starting the verification workflow. +Eine Abfrage unmittelbar nach dem Setzen oder Löschen eines Kontingents kann kurz den vorherigen Zustand zurückgeben. Fragen Sie das Kontingent erneut ab und bestätigen Sie den erwarteten Wert, bevor Sie die Überprüfung starten. ::: -### Clear a quota +### Kontingent löschen -Remove the limit without deleting objects: +Entfernen Sie das Limit, ohne Objekte zu löschen: ```bash rc bucket quota clear rustfs/my-bucket rc bucket quota info rustfs/my-bucket ``` -The bucket becomes unlimited after the configuration change is applied. +Der Bucket wird unbegrenzt, nachdem die Konfigurationsänderung angewendet wurde. -## Advanced quota checks +## Erweiterte Kontingentprüfungen -`rc 0.1.29` does not expose commands for detailed usage statistics or advisory checks for proposed writes. Use the RustFS Admin API for these operations. Requests must use AWS Signature Version 4 with an active RustFS credential. +`rc 0.1.29` stellt keine Befehle für detaillierte Nutzungsstatistiken oder unverbindliche Prüfungen geplanter Schreibvorgänge bereit. Verwenden Sie für diese Operationen die RustFS-Admin-API. Anfragen müssen AWS Signature Version 4 mit aktiven RustFS-Zugangsdaten verwenden. -The examples use these shell variables: +Die Beispiele verwenden diese Shell-Variablen: ```bash export RUSTFS_ENDPOINT=http://localhost:9000 @@ -124,15 +124,15 @@ export RUSTFS_SECRET_KEY= export BUCKET_NAME=my-bucket ``` -:::warning[Protect credentials] +:::warning[Zugangsdaten schützen] -Environment variables are convenient for local testing but may be visible to processes running as the same operating-system user. Use your platform's secret manager or a restricted credentials file in production. +Umgebungsvariablen sind für lokale Tests praktisch, können aber für Prozesse sichtbar sein, die als derselbe Betriebssystembenutzer laufen. Verwenden Sie in der Produktion die Geheimnisverwaltung Ihrer Plattform oder eine eingeschränkte Zugangsdatendatei. ::: -### Read detailed usage statistics +### Detaillierte Nutzungsstatistik lesen -Use the statistics endpoint to retrieve the limit, current usage, remaining bytes, and percentage used: +Verwenden Sie den Statistikendpunkt, um das Limit, die aktuelle Nutzung, die verbleibenden Bytes und den genutzten Prozentsatz abzurufen: ```bash curl --fail-with-body \ @@ -151,11 +151,11 @@ curl --fail-with-body \ } ``` -Usage values come from RustFS data-usage accounting. Allow time for that view to reflect very recent changes before using the statistics response for external billing or orchestration. +Die Nutzungswerte stammen aus der Datennutzungsabrechnung von RustFS. Warten Sie, bis diese Sicht sehr aktuelle Änderungen widerspiegelt, bevor Sie die Statistikantwort für externe Abrechnung oder Orchestrierung verwenden. -### Check a proposed upload +### Geplanten Upload prüfen -Check whether a 64 MiB upload would fit without writing an object: +Prüfen Sie, ob ein Upload von 64 MiB passen würde, ohne ein Objekt zu schreiben: ```bash curl --fail-with-body \ @@ -167,11 +167,11 @@ curl --fail-with-body \ "${RUSTFS_ENDPOINT}/rustfs/admin/v3/quota-check/${BUCKET_NAME}" ``` -The `allowed` field reports the decision. This check is advisory: another write can consume capacity before the planned upload starts, so the actual upload remains authoritative. +Das Feld `allowed` meldet die Entscheidung. Diese Prüfung ist unverbindlich: Ein anderer Schreibvorgang kann Kapazität verbrauchen, bevor der geplante Upload beginnt. Deshalb bleibt der tatsächliche Upload maßgeblich. -## Verification +## Überprüfung -Set a small test quota, upload an object that fits, and then attempt to upload an object that exceeds the remaining capacity: +Setzen Sie ein kleines Testkontingent, laden Sie ein Objekt hoch, das hineinpasst, und versuchen Sie anschließend, ein Objekt hochzuladen, das die verbleibende Kapazität überschreitet: ```bash rc bucket quota set rustfs/my-bucket 1M @@ -183,9 +183,9 @@ rc object copy /tmp/quota-small.bin rustfs/my-bucket/hello.bin rc object copy /tmp/quota-large.bin rustfs/my-bucket/too-large.bin ``` -The 256 KiB object succeeds. The 2 MiB object exceeds the 1 MiB bucket quota, so `rc` exits with an error and RustFS does not create `too-large.bin`. +Das Objekt von 256 KiB gelingt. Das Objekt von 2 MiB überschreitet das Bucket-Kontingent von 1 MiB. Deshalb endet `rc` mit einem Fehler, und RustFS erstellt `too-large.bin` nicht. -Delete the first object and clear the test quota: +Löschen Sie das erste Objekt und entfernen Sie das Testkontingent: ```bash rc object remove rustfs/my-bucket/hello.bin --force @@ -193,12 +193,12 @@ rc bucket quota clear rustfs/my-bucket rc bucket quota info rustfs/my-bucket ``` -Confirm that the final query reports `Quota: unlimited`. +Prüfen Sie, dass die letzte Abfrage `Quota: unlimited` meldet. -If quota enforcement cannot read or parse its internal configuration, RustFS logs `Bucket quota check degraded to allow` and permits the write. Monitor for this warning because it means quota enforcement is temporarily unavailable. +Wenn die Kontingentdurchsetzung ihre interne Konfiguration nicht lesen oder auswerten kann, protokolliert RustFS `Bucket quota check degraded to allow` und lässt den Schreibvorgang zu. Überwachen Sie diese Warnung, weil sie bedeutet, dass die Kontingentdurchsetzung vorübergehend nicht verfügbar ist. -## Next steps +## Nächste Schritte -- [Create a bucket](./creation.md) -- [Manage lifecycle rules](../lifecycle-management.md) -- [Configure observability](/operations/observability) \ No newline at end of file +- [Bucket erstellen](./creation.md) +- [Lebenszyklusregeln verwalten](../lifecycle-management.md) +- [Observability konfigurieren](/de/operations/observability) diff --git a/content/de/administration/data/bucket/replication.md b/content/de/administration/data/bucket/replication.md index 37642ae90..709118ed6 100644 --- a/content/de/administration/data/bucket/replication.md +++ b/content/de/administration/data/bucket/replication.md @@ -1,46 +1,46 @@ --- -title: "Bucket Replication" -description: "Configure, validate, and monitor asynchronous replication between versioned RustFS buckets." +title: "Bucket-Replikation" +description: "Konfigurieren, prüfen und überwachen Sie die asynchrone Replikation zwischen versionierten RustFS-Buckets." --- -RustFS bucket replication copies selected object versions from a source bucket to a target bucket. Use it to maintain a remote copy of bucket data, distribute objects between deployments, or prepare a secondary copy for recovery workflows. +Die Bucket-Replikation von RustFS kopiert ausgewählte Objektversionen von einem Quell-Bucket in einen Ziel-Bucket. Damit halten Sie eine entfernte Kopie der Bucket-Daten vor, verteilen Objekte zwischen Bereitstellungen oder bereiten eine zweite Kopie für Wiederherstellungsabläufe vor. -## Overview +## Überblick -Bucket replication has two configuration layers: +Die Bucket-Replikation hat zwei Konfigurationsebenen: -1. A **remote target** stores the target endpoint, bucket, credentials, and generated target ARN. -2. An S3 **replication configuration** attaches rules to the source bucket and references that target ARN. +1. Ein **entferntes Ziel** speichert den Zielendpunkt, den Bucket, die Zugangsdaten und die erzeugte Ziel-ARN. +2. Eine S3-**Replikationskonfiguration** bindet Regeln an den Quell-Bucket und verweist auf diese Ziel-ARN. -Both the source and target buckets must have versioning enabled. RustFS verifies the target connection and target-bucket versioning when you register the remote target. It rejects a replication configuration whose enabled rules reference an unknown or stale target ARN. +Quell- und Ziel-Bucket müssen die Versionierung aktiviert haben. RustFS prüft die Zielverbindung und die Versionierung des Ziel-Buckets, wenn Sie das entfernte Ziel registrieren. Eine Replikationskonfiguration, deren aktivierte Regeln auf eine unbekannte oder veraltete Ziel-ARN verweisen, wird abgelehnt. -Replication is asynchronous by default. A successful source upload means RustFS accepted the source object; it does not mean the target copy is already complete. +Die Replikation ist standardmäßig asynchron. Ein erfolgreicher Upload auf der Quelle bedeutet, dass RustFS das Quellobjekt angenommen hat. Er bedeutet nicht, dass die Zielkopie bereits abgeschlossen ist. -Rules can select objects by prefix or object tags and control these behaviors: +Regeln können Objekte nach Präfix oder Objekt-Tags auswählen und steuern dieses Verhalten: -| Rule setting | Behavior | +| Regeleinstellung | Verhalten | | --- | --- | -| `Status` | Enables or disables the rule. | -| `Filter` | Restricts replication by key prefix, object tags, or both. | -| `ExistingObjectReplication` | Includes objects that existed before the rule when set to `Enabled`. | -| `DeleteMarkerReplication` | Replicates delete markers when set to `Enabled`. | -| `DeleteReplication` | Replicates deletion of a specific object version when set to `Enabled`. | -| `Destination` | Identifies the registered remote target by ARN. | +| `Status` | Aktiviert oder deaktiviert die Regel. | +| `Filter` | Beschränkt die Replikation auf ein Schlüsselpräfix, Objekt-Tags oder beides. | +| `ExistingObjectReplication` | Schließt Objekte ein, die vor der Regel vorhanden waren, wenn der Wert `Enabled` ist. | +| `DeleteMarkerReplication` | Repliziert Löschmarker, wenn der Wert `Enabled` ist. | +| `DeleteReplication` | Repliziert das Löschen einer bestimmten Objektversion, wenn der Wert `Enabled` ist. | +| `Destination` | Identifiziert das registrierte entfernte Ziel über die ARN. | -Bucket replication is directional. Configure a separate target and rule in the opposite direction if both buckets must accept writes and replicate them to each other. Do not confuse bucket replication with [site replication](/operations/high-availability/site-replication), which synchronizes broader site configuration and identity data. +Die Bucket-Replikation ist gerichtet. Konfigurieren Sie ein separates Ziel und eine separate Regel in der Gegenrichtung, wenn beide Buckets Schreibvorgänge annehmen und sie zueinander replizieren sollen. Verwechseln Sie die Bucket-Replikation nicht mit der [Site-Replikation](/de/operations/high-availability/site-replication), die eine breitere Standortkonfiguration und Identitätsdaten synchronisiert. -## Configuration +## Konfiguration -### Requirements +### Voraussetzungen -- A source RustFS deployment and a reachable target S3-compatible deployment. -- A source bucket and target bucket with versioning enabled. -- A dedicated target credential that can inspect the target bucket's versioning and write replicated object versions and delete markers. -- A source administrator allowed to manage remote targets and replication configuration. -- Network access from every source node that can run replication work to the target endpoint. -- The RustFS [`rc`](/operations/rc) client installed on an administration host. +- Eine RustFS-Quellbereitstellung und eine erreichbare S3-kompatible Zielbereitstellung. +- Ein Quell-Bucket und ein Ziel-Bucket mit aktivierter Versionierung. +- Eigene Ziel-Zugangsdaten, die die Versionierung des Ziel-Buckets abfragen und replizierte Objektversionen sowie Löschmarker schreiben können. +- Ein Quelladministrator, der entfernte Ziele und die Replikationskonfiguration verwalten darf. +- Netzwerkzugriff von jedem Quellknoten, der Replikationsarbeit ausführen kann, auf den Zielendpunkt. +- Der RustFS-Client [`rc`](/de/operations/rc), installiert auf einem Administrationshost. -Configure one `rc` alias for each deployment. Use dedicated credentials and replace the example endpoints before running the commands: +Konfigurieren Sie für jede Bereitstellung einen `rc`-Alias. Verwenden Sie eigene Zugangsdaten und ersetzen Sie die Beispielendpunkte, bevor Sie die Befehle ausführen: ```bash rc alias set source https://source.example.com:9000 \ @@ -54,43 +54,43 @@ rc alias set target https://target.example.com:9000 \ rc alias list ``` -The source deployment uses the target alias credentials when it registers the remote target. `rc alias list` displays endpoints but does not print secret keys. +Die Quellbereitstellung verwendet die Zugangsdaten des Zielalias, wenn sie das entfernte Ziel registriert. `rc alias list` zeigt Endpunkte an, gibt aber keine geheimen Zugriffsschlüssel aus. -:::warning[Protect target credentials] +:::warning[Ziel-Zugangsdaten schützen] -RustFS stores the target credential as part of the source bucket's remote-target configuration. Use a dedicated credential with access limited to the target bucket and do not reuse a root credential. +RustFS speichert die Ziel-Zugangsdaten als Teil der Konfiguration des entfernten Ziels am Quell-Bucket. Verwenden Sie eigene Zugangsdaten mit Zugriff nur auf den Ziel-Bucket und verwenden Sie keine Root-Anmeldedaten erneut. ::: -### Permissions +### Berechtigungen -Source-side administration uses these policy actions: +Die Administration auf der Quellseite verwendet diese Richtlinienaktionen: -| Operation | Required action | +| Operation | Erforderliche Aktion | | --- | --- | -| Register, update, or remove a remote target | `admin:SetBucketTarget` | -| List remote targets | `admin:GetBucketTarget` | -| Read replication metrics | `admin:GetReplicationMetrics` | -| Apply or delete replication configuration | `s3:PutReplicationConfiguration` | -| Read replication configuration | `s3:GetReplicationConfiguration` | +| Entferntes Ziel registrieren, aktualisieren oder entfernen | `admin:SetBucketTarget` | +| Entfernte Ziele auflisten | `admin:GetBucketTarget` | +| Replikationsmetriken lesen | `admin:GetReplicationMetrics` | +| Replikationskonfiguration anwenden oder löschen | `s3:PutReplicationConfiguration` | +| Replikationskonfiguration lesen | `s3:GetReplicationConfiguration` | -The target credential must pass RustFS target validation, which checks bucket access, versioning, replicated-object writes, replicated delete markers, and object-version deletion. When Object Lock is enabled on the source bucket, the target must have compatible Object Lock support. +Die Ziel-Zugangsdaten müssen die Zielprüfung von RustFS bestehen. Sie prüft den Bucket-Zugriff, die Versionierung, Schreibvorgänge replizierter Objekte, replizierte Löschmarker und das Löschen von Objektversionen. Wenn Object Lock auf dem Quell-Bucket aktiviert ist, muss das Ziel eine kompatible Object-Lock-Unterstützung bieten. -### Create and version the buckets +### Buckets erstellen und versionieren -Create the source bucket: +Erstellen Sie den Quell-Bucket: ```bash rc bucket create source/my-bucket ``` -Create the target bucket: +Erstellen Sie den Ziel-Bucket: ```bash rc bucket create target/my-bucket-replica ``` -Enable versioning on both buckets: +Aktivieren Sie die Versionierung auf beiden Buckets: ```bash rc bucket version enable source/my-bucket @@ -100,53 +100,53 @@ rc bucket version info source/my-bucket rc bucket version info target/my-bucket-replica ``` -Do not suspend source-bucket versioning while replication is configured. +Setzen Sie die Versionierung des Quell-Buckets nicht aus, solange die Replikation konfiguriert ist. -## Usage +## Verwendung -### Configure replication in the Console +### Replikation in der Console konfigurieren -The RustFS Console combines remote-target registration and replication-rule configuration in one form. +Die RustFS-Console fasst die Registrierung des entfernten Ziels und die Konfiguration der Replikationsregel in einem Formular zusammen. -1. Sign in to the source deployment's Console. -2. Open **Buckets**, locate the source bucket, and select **Settings**. -3. Under **Data Protection**, enable **Versioning** if it is disabled. -4. Under **Automation**, select **Open Bucket Replication**. -5. Select **Add Replication Rule**. -6. Configure the destination and rule: +1. Melden Sie sich an der Console der Quellbereitstellung an. +2. Öffnen Sie **Buckets**, suchen Sie den Quell-Bucket und wählen Sie **Settings** (Einstellungen). +3. Aktivieren Sie unter **Data Protection** (Datenschutz) **Versioning** (Versionierung), falls sie deaktiviert ist. +4. Wählen Sie unter **Automation** (Automatisierung) **Open Bucket Replication** (Bucket-Replikation öffnen). +5. Wählen Sie **Add Replication Rule** (Replikationsregel hinzufügen). +6. Konfigurieren Sie Ziel und Regel: -| Console field | Value | +| Console-Feld | Wert | | --- | --- | -| **Priority** | Rule evaluation priority. The initial value is `1`. | -| **Mode** | Select **Asynchronous** or **Synchronous**. Asynchronous is selected by default. | -| **Endpoint** | Target S3 API address as `host:port`, without a URL scheme. | -| **Bucket** | Versioned destination bucket name. | -| **Access Key** and **Secret Key** | Dedicated credentials authorized to replicate into the destination bucket. | -| **Region** | Target region. The initial value is `us-east-1`. | -| **Storage Class** | Storage class applied at the destination. The initial value is `STANDARD`. | -| **Prefix** | Optional key prefix used to limit matching objects. | -| **Tags** | Optional object-tag name and value filters. Select **Add Tag** for additional filters. | -| **Use TLS** | Enables HTTPS for the destination connection. | -| **Replicate Existing Objects** | Includes objects created before the rule. Enabled by default. | -| **Replicate Delete Markers** | Copies delete markers to the destination. Enabled by default. | -| **Replicate Delete** | Copies deletion of a specific object version. Enabled by default. | -| **Health Check Interval** | Target health-check interval in seconds. The initial value is `60`. | -| **Bandwidth Limit** | Per-target transfer limit, selectable in KiB/s, MiB/s, or GiB/s. | - -7. Select **Save**. RustFS validates the source bucket, target connection, target credentials, and target-bucket versioning before accepting the rule. -8. Return to **Bucket Replication** to review the rule or select **Refresh** to update its displayed state. - -:::warning[Enable versioning on both deployments] - -The source and destination buckets must both have versioning enabled before you save the rule. Sign in to the target deployment's Console and enable versioning under **Buckets** → **Settings** → **Data Protection** when needed. +| **Priority** | Priorität der Regelauswertung. Der Anfangswert ist `1`. | +| **Mode** | Wählen Sie **Asynchronous** (asynchron) oder **Synchronous** (synchron). Asynchron ist standardmäßig ausgewählt. | +| **Endpoint** | S3-API-Adresse des Ziels als `host:port`, ohne URL-Schema. | +| **Bucket** | Name des versionierten Ziel-Buckets. | +| **Access Key** und **Secret Key** | Eigene Zugangsdaten, die zur Replikation in den Ziel-Bucket berechtigt sind. | +| **Region** | Zielregion. Der Anfangswert ist `us-east-1`. | +| **Storage Class** | Speicherklasse, die am Ziel angewendet wird. Der Anfangswert ist `STANDARD`. | +| **Prefix** | Optionales Schlüsselpräfix, das passende Objekte einschränkt. | +| **Tags** | Optionale Filter für Name und Wert von Objekt-Tags. Wählen Sie **Add Tag** (Tag hinzufügen) für weitere Filter. | +| **Use TLS** | Aktiviert HTTPS für die Zielverbindung. | +| **Replicate Existing Objects** | Schließt Objekte ein, die vor der Regel erstellt wurden. Standardmäßig aktiviert. | +| **Replicate Delete Markers** | Kopiert Löschmarker zum Ziel. Standardmäßig aktiviert. | +| **Replicate Delete** | Kopiert das Löschen einer bestimmten Objektversion. Standardmäßig aktiviert. | +| **Health Check Interval** | Intervall der Integritätsprüfung des Ziels in Sekunden. Der Anfangswert ist `60`. | +| **Bandwidth Limit** | Übertragungsgrenze je Ziel, wählbar in KiB/s, MiB/s oder GiB/s. | + +7. Wählen Sie **Save** (Speichern). RustFS prüft den Quell-Bucket, die Zielverbindung, die Ziel-Zugangsdaten und die Versionierung des Ziel-Buckets, bevor es die Regel annimmt. +8. Kehren Sie zu **Bucket Replication** (Bucket-Replikation) zurück, um die Regel zu prüfen, oder wählen Sie **Refresh** (Aktualisieren), um den angezeigten Zustand zu aktualisieren. + +:::warning[Versionierung auf beiden Bereitstellungen aktivieren] + +Quell- und Ziel-Bucket müssen beide die Versionierung aktiviert haben, bevor Sie die Regel speichern. Melden Sie sich bei Bedarf an der Console der Zielbereitstellung an und aktivieren Sie die Versionierung unter **Buckets** → **Settings** → **Data Protection**. ::: -For repeatable automation or configuration management, use the `rc` workflow below. +Verwenden Sie für wiederholbare Automatisierung oder Konfigurationsverwaltung den folgenden `rc`-Ablauf. -### Add a replication rule with rc +### Replikationsregel mit rc hinzufügen -Create an asynchronous rule that copies new and existing objects and propagates delete markers and explicit version deletions: +Erstellen Sie eine asynchrone Regel, die neue und vorhandene Objekte kopiert und Löschmarker sowie ausdrückliche Versionslöschungen weitergibt: ```bash rc bucket replication add source/my-bucket \ @@ -156,9 +156,9 @@ rc bucket replication add source/my-bucket \ --replicate delete,delete-marker,existing-objects ``` -`rc` registers the target, obtains its generated ARN, and applies the replication rule in one operation. Omit `--replicate` flags for behaviors you do not want. Add `--sync` only when writes must wait for synchronous replication. +`rc` registriert das Ziel, erhält die erzeugte ARN und wendet die Replikationsregel in einem Vorgang an. Lassen Sie `--replicate`-Flags für Verhalten weg, das Sie nicht möchten. Fügen Sie `--sync` nur hinzu, wenn Schreibvorgänge auf die synchrone Replikation warten müssen. -To limit replication to a prefix, add `--prefix`: +Um die Replikation auf ein Präfix zu beschränken, fügen Sie `--prefix` hinzu: ```bash rc bucket replication add source/my-bucket \ @@ -169,18 +169,18 @@ rc bucket replication add source/my-bucket \ --replicate delete-marker,existing-objects ``` -Objects that do not match an enabled rule remain only in the source bucket. Use `--bandwidth` to set a byte-per-second limit, `--healthcheck-seconds` to change the target health-check interval, and `--storage-class` to override the destination storage class. +Objekte, die auf keine aktivierte Regel passen, bleiben nur im Quell-Bucket. Verwenden Sie `--bandwidth`, um eine Grenze in Bytes je Sekunde zu setzen, `--healthcheck-seconds`, um das Intervall der Integritätsprüfung des Ziels zu ändern, und `--storage-class`, um die Speicherklasse am Ziel zu überschreiben. -### List and update rules +### Regeln auflisten und aktualisieren -List the active rules: +Listen Sie die aktiven Regeln auf: ```bash rc bucket replication list source/my-bucket rc bucket replication list source/my-bucket --json ``` -Update a rule by its ID. Only supplied settings are changed: +Aktualisieren Sie eine Regel über ihre ID. Nur angegebene Einstellungen werden geändert: ```bash rc bucket replication update source/my-bucket \ @@ -190,25 +190,25 @@ rc bucket replication update source/my-bucket \ --healthcheck-seconds 60 ``` -Use `--status Enabled|Disabled` to enable or disable a rule and `--sync true|false` to change its replication mode. +Verwenden Sie `--status Enabled|Disabled`, um eine Regel zu aktivieren oder zu deaktivieren, und `--sync true|false`, um ihren Replikationsmodus zu ändern. -### Export and import configuration +### Konfiguration exportieren und importieren -Export the complete replication configuration for review or backup: +Exportieren Sie die vollständige Replikationskonfiguration zur Prüfung oder Sicherung: ```bash rc bucket replication export source/my-bucket --json > replication.json ``` -The export includes remote-target metadata and the target Access Key, although the Secret Key is omitted. Protect the file as sensitive configuration. +Der Export enthält Metadaten des entfernten Ziels und den Zugriffsschlüssel des Ziels. Der geheime Zugriffsschlüssel wird ausgelassen. Behandeln Sie die Datei als sensible Konfiguration. -Import a previously exported configuration: +Importieren Sie eine zuvor exportierte Konfiguration: ```bash rc bucket replication import source/my-bucket replication.json ``` -### Delete replication configuration +### Replikationskonfiguration löschen ```bash rc bucket replication remove source/my-bucket --id replicate-all @@ -217,49 +217,49 @@ rc bucket replication remove source/my-bucket --id replicate-all rc bucket replication remove source/my-bucket --all ``` -RustFS also removes replication remote targets referenced by the deleted configuration. It does not delete objects or versions already copied to the target bucket. Remove or retain those objects according to the target bucket's lifecycle and retention requirements. +RustFS entfernt außerdem entfernte Replikationsziele, auf die die gelöschte Konfiguration verweist. Objekte oder Versionen, die bereits in den Ziel-Bucket kopiert wurden, werden nicht gelöscht. Entfernen oder behalten Sie diese Objekte entsprechend den Lebenszyklus- und Aufbewahrungsanforderungen des Ziel-Buckets. -:::note[rc 0.1.29 removal response] +:::note[Antwort von rc 0.1.29 beim Entfernen] -After RustFS removes the replication configuration and its targets, `rc 0.1.29` can report `Remote target not found` while attempting a second target cleanup. Run `rc bucket replication list source/my-bucket --json`; an empty `rules` array confirms that the configuration was removed. +Nachdem RustFS die Replikationskonfiguration und ihre Ziele entfernt hat, kann `rc 0.1.29` beim Versuch einer zweiten Zielbereinigung `Remote target not found` melden. Führen Sie `rc bucket replication list source/my-bucket --json` aus. Ein leeres `rules`-Array bestätigt, dass die Konfiguration entfernt wurde. ::: -## Verification +## Überprüfung -### Check target readiness +### Bereitschaft des Ziels prüfen -`rc bucket replication add` checks source access, target connectivity, target credentials, and bucket versioning before it creates the rule. Confirm the resulting destination and rule settings: +`rc bucket replication add` prüft den Quellzugriff, die Zielkonnektivität, die Ziel-Zugangsdaten und die Bucket-Versionierung, bevor es die Regel erstellt. Bestätigen Sie das resultierende Ziel und die Regeleinstellungen: ```bash rc bucket replication list source/my-bucket --json ``` -### Replicate an object +### Objekt replizieren -Upload a test object to the source: +Laden Sie ein Testobjekt auf die Quelle hoch: ```bash printf 'hello from RustFS replication\n' > /tmp/hello.txt rc object copy /tmp/hello.txt source/my-bucket/hello.txt ``` -Inspect the source object: +Rufen Sie die Metadaten des Quellobjekts ab (Head): ```bash rc object stat source/my-bucket/hello.txt --json ``` -Because replication is asynchronous by default, the target object might not appear immediately. Repeat this command until it succeeds: +Weil die Replikation standardmäßig asynchron ist, erscheint das Zielobjekt möglicherweise nicht sofort. Wiederholen Sie diesen Befehl, bis er erfolgreich ist: ```bash rc object stat target/my-bucket-replica/hello.txt --json rc object show target/my-bucket-replica/hello.txt ``` -Compare the source and target `etag` and `size_bytes` values, then confirm that `object show` returns the expected content. +Vergleichen Sie die Werte `etag` und `size_bytes` von Quelle und Ziel und prüfen Sie anschließend, dass `object show` den erwarteten Inhalt zurückgibt. -To verify delete-marker replication, delete the source object and list versions on both buckets: +Um die Replikation von Löschmarkern zu prüfen, löschen Sie das Quellobjekt und listen Sie die Versionen auf beiden Buckets auf: ```bash rc object remove source/my-bucket/hello.txt --force @@ -268,31 +268,31 @@ rc bucket version list source/my-bucket/hello.txt --json rc bucket version list target/my-bucket-replica/hello.txt --json ``` -When delete-marker replication succeeds, the latest entry on both buckets has `is_delete_marker: true`. +Wenn die Replikation von Löschmarkern erfolgreich ist, hat der neueste Eintrag auf beiden Buckets `is_delete_marker: true`. -### Inspect replication metrics +### Replikationsmetriken anzeigen ```bash rc bucket replication status source/my-bucket rc bucket replication status source/my-bucket --json ``` -The command returns the source node's current in-memory replication statistics. Metrics can remain zero even after an object reaches the destination, so use them together with target-object and version checks rather than as the only verification signal. +Der Befehl gibt die aktuellen Replikationsstatistiken des Quellknotens im Arbeitsspeicher zurück. Metriken können null bleiben, auch nachdem ein Objekt das Ziel erreicht hat. Verwenden Sie sie deshalb zusammen mit Prüfungen des Zielobjekts und der Versionen und nicht als einziges Überprüfungssignal. -### Troubleshoot failures +### Fehler beheben -| Symptom | Check | +| Symptom | Prüfung | | --- | --- | -| `bucket versioning must be enabled` | Enable versioning on the source bucket. | -| Target registration reports `not versioned` | Enable versioning on the target bucket. | -| `replication target configuration not found` | Recheck the target alias, credentials, and destination bucket, then rerun `replication add`. | -| Rule reports a stale target | Refresh the rule list and retry `replication add`; if it persists, remove the failed configuration and recreate the target. | -| Target object does not appear | Check target reachability, credentials, target quota, and `rc bucket replication status`. | -| Replication fails | Inspect source-node logs for the target ARN and object key. | -| Target removal is disallowed | Delete or replace the replication configuration before removing a referenced target. | - -## Next steps - -- [Manage bucket lifecycle](../lifecycle-management.md) -- [Configure bucket quotas](./quota.md) -- [Configure observability](/operations/observability) \ No newline at end of file +| `bucket versioning must be enabled` | Aktivieren Sie die Versionierung auf dem Quell-Bucket. | +| Die Zielregistrierung meldet `not versioned` | Aktivieren Sie die Versionierung auf dem Ziel-Bucket. | +| `replication target configuration not found` | Prüfen Sie Zielalias, Zugangsdaten und Ziel-Bucket erneut und führen Sie `replication add` noch einmal aus. | +| Die Regel meldet ein veraltetes Ziel | Aktualisieren Sie die Regelliste und wiederholen Sie `replication add`. Wenn der Zustand bleibt, entfernen Sie die fehlgeschlagene Konfiguration und erstellen Sie das Ziel neu. | +| Das Zielobjekt erscheint nicht | Prüfen Sie die Erreichbarkeit des Ziels, die Zugangsdaten, das Zielkontingent und `rc bucket replication status`. | +| Die Replikation schlägt fehl | Prüfen Sie die Protokolle des Quellknotens auf die Ziel-ARN und den Objektschlüssel. | +| Das Entfernen des Ziels ist nicht zulässig | Löschen oder ersetzen Sie die Replikationskonfiguration, bevor Sie ein referenziertes Ziel entfernen. | + +## Nächste Schritte + +- [Bucket-Lebenszyklus verwalten](../lifecycle-management.md) +- [Bucket-Kontingente konfigurieren](./quota.md) +- [Observability konfigurieren](/de/operations/observability) diff --git a/content/de/administration/data/lifecycle-management.md b/content/de/administration/data/lifecycle-management.md index 9cc05f875..29ba14c2f 100644 --- a/content/de/administration/data/lifecycle-management.md +++ b/content/de/administration/data/lifecycle-management.md @@ -1,21 +1,21 @@ --- -title: "Lifecycle Management" -description: "Configure, inspect, and maintain RustFS object lifecycle rules with the rc command-line client." +title: "Lebenszyklusverwaltung" +description: "Konfigurieren, prüfen und pflegen Sie Lebenszyklusregeln für RustFS-Objekte mit dem Kommandozeilenclient rc." --- -RustFS lifecycle management applies expiration and transition rules to objects in a bucket. This page shows how to manage those rules with `rc`, verify a transition, and restore a temporary local copy of transitioned data. +Die Lebenszyklusverwaltung von RustFS wendet Ablauf- und Übergangsregeln auf Objekte in einem Bucket an. Auf dieser Seite verwalten Sie diese Regeln mit `rc`, prüfen einen Übergang und stellen eine temporäre lokale Kopie übertragener Daten wieder her. -Before you begin, [install `rc`](/operations/rc), configure an alias named `local`, and create `my-bucket`. To transition objects, first register the target in [Tiered Storage](/administration/data/tiered-storage) and note its uppercase tier name. +Bevor Sie beginnen, [installieren Sie `rc`](/de/operations/rc), konfigurieren Sie einen Alias namens `local` und erstellen Sie `my-bucket`. Um Objekte zu übertragen, registrieren Sie zuerst das Ziel unter [Gestufte Speicherung](/de/administration/data/tiered-storage) und notieren Sie den Stufennamen in Großbuchstaben. -:::note[Asynchronous evaluation] +:::note[Asynchrone Auswertung] -Lifecycle rules do not process every eligible object immediately. The [Object Scanner](/administration/data/object/scanner) evaluates lifecycle work in the background. +Lebenszyklusregeln verarbeiten nicht jedes geeignete Objekt sofort. Der [Objekt-Scanner](/de/administration/data/object/scanner) wertet Lebenszyklusarbeit im Hintergrund aus. ::: -## Add an expiration rule +## Ablaufregel hinzufügen -Expire objects under the `logs/` prefix 30 days after creation: +Lassen Sie Objekte unter dem Präfix `logs/` 30 Tage nach der Erstellung ablaufen: ```bash rc bucket lifecycle rule add local/my-bucket \ @@ -23,11 +23,11 @@ rc bucket lifecycle rule add local/my-bucket \ --expiry-days 30 ``` -The command creates an enabled rule and returns its generated rule ID. Record that ID when you need to edit or remove this specific rule. +Der Befehl erstellt eine aktivierte Regel und gibt die erzeugte Regel-ID zurück. Notieren Sie diese ID, wenn Sie genau diese Regel bearbeiten oder entfernen müssen. -## Add a transition rule +## Übergangsregel hinzufügen -Move object data to the registered `COLDTIER` tier after 90 days: +Verschieben Sie Objektdaten nach 90 Tagen in die registrierte Stufe `COLDTIER`: ```bash rc bucket lifecycle rule add local/my-bucket \ @@ -35,9 +35,9 @@ rc bucket lifecycle rule add local/my-bucket \ --storage-class COLDTIER ``` -`--storage-class` must match a registered tier name. Adding the rule does not create the tier or validate an AWS storage-class label as a RustFS tier. +`--storage-class` muss mit einem registrierten Stufennamen übereinstimmen. Das Hinzufügen der Regel erstellt die Stufe nicht und prüft eine AWS-Speicherklassenbezeichnung nicht als RustFS-Stufe. -You can combine expiration and transition options in one rule. Use the noncurrent-version options only for a versioned bucket: +Sie können Ablauf- und Übergangsoptionen in einer Regel kombinieren. Verwenden Sie die Optionen für nicht aktuelle Versionen nur bei einem versionierten Bucket: ```bash rc bucket lifecycle rule add local/my-bucket \ @@ -46,15 +46,15 @@ rc bucket lifecycle rule add local/my-bucket \ --noncurrent-expiry-days 365 ``` -## Inspect and update rules +## Regeln anzeigen und aktualisieren -List the current rules and note the ID of the rule you want to change: +Listen Sie die aktuellen Regeln auf und notieren Sie die ID der Regel, die Sie ändern möchten: ```bash rc bucket lifecycle rule list local/my-bucket ``` -Change a rule's expiration period or disable it without deleting it: +Ändern Sie die Ablaufdauer einer Regel oder deaktivieren Sie sie, ohne sie zu löschen: ```bash rc bucket lifecycle rule edit local/my-bucket \ @@ -65,30 +65,30 @@ rc bucket lifecycle rule edit local/my-bucket \ --disable true ``` -Remove one rule by ID. Use `--all` only when you intend to remove the bucket's complete lifecycle configuration: +Entfernen Sie eine Regel anhand der ID. Verwenden Sie `--all` nur, wenn Sie die vollständige Lebenszykluskonfiguration des Buckets entfernen möchten: ```bash rc bucket lifecycle rule remove local/my-bucket --id rc bucket lifecycle rule remove local/my-bucket --all ``` -## Export and import rules +## Regeln exportieren und importieren -Export the bucket's lifecycle configuration before a bulk change: +Exportieren Sie die Lebenszykluskonfiguration des Buckets vor einer umfangreichen Änderung: ```bash rc bucket lifecycle rule export local/my-bucket > lifecycle.json ``` -Importing a file replaces the lifecycle configuration sent to the bucket. Review the JSON before applying it: +Der Import einer Datei ersetzt die Lebenszykluskonfiguration, die an den Bucket gesendet wird. Prüfen Sie das JSON, bevor Sie es anwenden: ```bash rc bucket lifecycle rule import local/my-bucket lifecycle.json ``` -## Confirm a lifecycle transition +## Lebenszyklusübergang bestätigen -After an object becomes eligible under its lifecycle rule, inspect it on the source cluster: +Nachdem ein Objekt unter seiner Lebenszyklusregel geeignet geworden ist, rufen Sie seine Metadaten auf dem Quellcluster ab (Head): ```bash aws s3api head-object \ @@ -97,7 +97,7 @@ aws s3api head-object \ --endpoint-url http://localhost:9000 ``` -After the transition completes, the response reports the registered tier name as the storage class: +Nach Abschluss des Übergangs meldet die Antwort den registrierten Stufennamen als Speicherklasse: ```json { @@ -105,9 +105,9 @@ After the transition completes, the response reports the registered tier name as } ``` -The response can contain additional object metadata. Before the transition completes, `StorageClass` may be absent or may not yet report `COLDTIER`. +Die Antwort kann weitere Objektmetadaten enthalten. Bevor der Übergang abgeschlossen ist, kann `StorageClass` fehlen oder noch nicht `COLDTIER` melden. -Read the object through the source RustFS endpoint as usual: +Lesen Sie das Objekt wie gewohnt über den RustFS-Quellendpunkt: ```bash aws s3 cp \ @@ -116,23 +116,23 @@ aws s3 cp \ --endpoint-url http://localhost:9000 ``` -RustFS reads transitioned data through the source bucket and object key. Applications do not need to address the target bucket directly. +RustFS liest übertragene Daten über den Quell-Bucket und den Objektschlüssel. Anwendungen müssen den Ziel-Bucket nicht direkt adressieren. -## Restore a local copy +## Lokale Kopie wiederherstellen -Request a temporary local copy of a transitioned object and retain it for seven days: +Fordern Sie eine temporäre lokale Kopie eines übertragenen Objekts an und behalten Sie sie sieben Tage: ```bash rc bucket lifecycle restore local/my-bucket/hello.txt --days 7 ``` -While the copy-back is running, `HEAD` reports `x-amz-restore: ongoing-request="true"`. After completion, it reports `ongoing-request="false"` with an expiry date. A second restore submitted while one is running returns `RestoreAlreadyInProgress`. +Während das Rückkopieren läuft, meldet `HEAD` `x-amz-restore: ongoing-request="true"`. Nach dem Abschluss meldet es `ongoing-request="false"` mit einem Ablaufdatum. Eine zweite Wiederherstellung, die während einer laufenden Wiederherstellung gesendet wird, gibt `RestoreAlreadyInProgress` zurück. -When the restore period expires, RustFS removes the local restored copy and its restore metadata. The transitioned object remains available from the remote tier. +Wenn der Wiederherstellungszeitraum abläuft, entfernt RustFS die lokale wiederhergestellte Kopie und ihre Wiederherstellungsmetadaten. Das übertragene Objekt bleibt über die entfernte Stufe verfügbar. -## Command compatibility +## Befehlskompatibilität -The latest `rc` also accepts `rc ilm` as a compatibility alias. We recommend the noun-first `rc bucket lifecycle` form for new commands and scripts: +Das aktuelle `rc` akzeptiert `rc ilm` zusätzlich als Kompatibilitätsalias. Wir empfehlen für neue Befehle und Skripte die Form `rc bucket lifecycle`, bei der das Substantiv voransteht: ```bash rc bucket lifecycle --help @@ -140,6 +140,6 @@ rc bucket lifecycle rule --help rc bucket lifecycle tier --help ``` -## Next steps +## Nächste Schritte -Review [Tiered Storage](/administration/data/tiered-storage) to monitor or maintain remote tiers, and use [object creation](/administration/data/object/creation) to create test objects for a lifecycle rule. +Lesen Sie [Gestufte Speicherung](/de/administration/data/tiered-storage), um entfernte Stufen zu überwachen oder zu pflegen, und verwenden Sie [Objekt erstellen](/de/administration/data/object/creation), um Testobjekte für eine Lebenszyklusregel anzulegen. diff --git a/content/de/administration/data/object/creation.md b/content/de/administration/data/object/creation.md index b0c5ca07b..837155f0c 100644 --- a/content/de/administration/data/object/creation.md +++ b/content/de/administration/data/object/creation.md @@ -1,53 +1,53 @@ --- -title: "Object Creation" -description: "Create objects using the RustFS UI, rc, or the S3 API." +title: "Objekt erstellen" +description: "Erstellen Sie Objekte über die RustFS-Oberfläche, mit rc oder über die S3-API." --- -Objects are the fundamental storage units in RustFS, containing data, metadata, and a unique key. This guide covers object creation (upload). +Objekte sind die grundlegenden Speichereinheiten in RustFS. Sie enthalten Daten, Metadaten und einen eindeutigen Objektschlüssel. Diese Anleitung beschreibt das Erstellen von Objekten (Upload). -## Requirements +## Voraussetzungen -- A running RustFS instance (see [Installation Guide](../../../installation/index.md)). -- [`rc`](/operations/rc) installed and configured with an alias for the command-line workflow. -- A target bucket. Create one by following [Bucket Creation](../bucket/creation.md). +- Eine laufende RustFS-Instanz (siehe [Installationsanleitung](../../../installation/index.md)). +- [`rc`](/de/operations/rc), installiert und mit einem Alias für den Kommandozeilenablauf konfiguriert. +- Ein Ziel-Bucket. Erstellen Sie einen Bucket wie unter [Bucket erstellen](../bucket/creation.md) beschrieben. -## Creating Objects +## Objekte erstellen -### Using the RustFS UI +### RustFS-Oberfläche verwenden -1. Log in to the RustFS Console. -2. Select the target bucket. -3. On the bucket page, in the top right corner, select **New Directory**, **New File**, or **Upload File/Folder**. -4. To upload from your local machine, click **Upload File/Folder**, select the files, and click **Start Upload**. +1. Melden Sie sich an der RustFS-Console an. +2. Wählen Sie den Ziel-Bucket. +3. Wählen Sie auf der Bucket-Seite oben rechts **New Directory** (Neues Verzeichnis), **New File** (Neue Datei) oder **Upload File/Folder** (Datei oder Ordner hochladen). +4. Um von Ihrem lokalen Rechner hochzuladen, klicken Sie auf **Upload File/Folder**, wählen Sie die Dateien aus und klicken Sie auf **Start Upload** (Upload starten). -![object creation from ui](images/upload_file_from_ui.png) +![Objekterstellung über die Oberfläche](images/upload_file_from_ui.png) -Click on an object to view its details. +Wählen Sie ein Objekt aus, um seine Details anzuzeigen. -![object details info](images/object_details_info.png) +![Objekt-Detailinformationen](images/object_details_info.png) -### Using `rc` +### `rc` verwenden -See the [`rc` guide](/operations/rc) for installation and alias configuration. +Installation und Alias-Konfiguration stehen in der [`rc`-Anleitung](/de/operations/rc). -Upload a file: +Laden Sie eine Datei hoch: ```bash rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt rc object list rustfs/my-bucket ``` -Verify the upload in the RustFS Console. +Prüfen Sie den Upload in der RustFS-Console. -### Using the API +### API verwenden -Upload a file via API: +Laden Sie eine Datei über die API hoch: ```http PUT /{bucketName}/{objectName} HTTP/1.1 ``` -S3 requests must be signed with AWS Signature V4, so use an S3 client rather than hand-crafting headers. With the [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) configured for your access keys: +S3-Anfragen müssen mit AWS Signature V4 signiert sein. Verwenden Sie deshalb einen S3-Client, anstatt Header von Hand zu setzen. Mit der für Ihre Zugriffsschlüssel konfigurierten [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html): ```bash aws s3api put-object \ @@ -57,19 +57,19 @@ aws s3api put-object \ --endpoint-url http://localhost:9000 ``` -Verify the upload in the RustFS Console. +Prüfen Sie den Upload in der RustFS-Console. -## Deleting Objects +## Objekte löschen -See [Object Deletion](./deletion.md). +Siehe [Objekt löschen](./deletion.md). -Use the following API for file deletion: +Um ein Objekt über die S3-API zu löschen, verwenden Sie: ```http DELETE /{bucketName}/{objectName} HTTP/1.1 ``` -Request example: +Beispiel für eine Anfrage: ```bash aws s3api delete-object \ @@ -78,4 +78,4 @@ aws s3api delete-object \ --endpoint-url http://localhost:9000 ``` -You can confirm the file has been deleted on the RustFS UI. +Prüfen Sie in der RustFS-Console, dass das Objekt nicht mehr angezeigt wird. diff --git a/content/de/administration/data/object/deletion.md b/content/de/administration/data/object/deletion.md index 5e3106239..9bb610ca3 100644 --- a/content/de/administration/data/object/deletion.md +++ b/content/de/administration/data/object/deletion.md @@ -1,27 +1,27 @@ --- -title: "Object Deletion" -description: "Delete objects using the RustFS UI, rc, or the S3 API." +title: "Objekt löschen" +description: "Löschen Sie Objekte über die RustFS-Oberfläche, mit rc oder über die S3-API." --- -This guide covers object deletion. +Diese Anleitung beschreibt das Löschen von Objekten. -## Requirements +## Voraussetzungen -- Install and configure [`rc`](/operations/rc) before using the command-line workflow. -- Confirm the alias, bucket, and object key before deleting an object. +- Installieren und konfigurieren Sie [`rc`](/de/operations/rc), bevor Sie den Kommandozeilenablauf verwenden. +- Prüfen Sie Alias, Bucket und Objektschlüssel, bevor Sie ein Objekt löschen. -## Using the RustFS UI +## RustFS-Oberfläche verwenden -1. Log in to the RustFS Console. -2. Select the bucket containing the file to be deleted. -3. On the bucket page, select the file to be deleted. -4. Click **Delete Selected Items** in the upper right corner, then click **Confirm** in the popup dialog. +1. Melden Sie sich an der RustFS-Console an. +2. Wählen Sie den Bucket, der das zu löschende Objekt enthält. +3. Wählen Sie auf der Bucket-Seite das zu löschende Objekt aus. +4. Wählen Sie oben rechts **Delete Selected Items** (Ausgewählte Elemente löschen) und anschließend **Confirm** (Bestätigen). -![object deletion from ui](images/delete_file_from_ui.png) +![Objektlöschung über die Oberfläche](images/delete_file_from_ui.png) -## Using `rc` +## `rc` verwenden -Delete a file: +Löschen Sie ein Objekt: ```bash rc object remove rustfs/my-bucket/hello.txt @@ -33,17 +33,17 @@ Removed: rustfs/my-bucket/hello.txt ✓ Removed 1 object(s). ``` -Verify the deletion in the RustFS Console. +Prüfen Sie die Löschung in der RustFS-Console. -## Using the API +## API verwenden -Delete a file via API: +Löschen Sie ein Objekt über die API: ```http DELETE /{bucketName}/{objectName} HTTP/1.1 ``` -S3 requests must be signed with AWS Signature V4, so use an S3 client rather than hand-crafting headers. With the [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) configured for your access keys: +S3-Anfragen müssen mit AWS Signature V4 signiert sein. Verwenden Sie deshalb einen S3-Client, anstatt Header von Hand zu setzen. Mit der für Ihre Zugriffsschlüssel konfigurierten [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html): ```bash aws s3api delete-object \ @@ -52,4 +52,4 @@ aws s3api delete-object \ --endpoint-url http://localhost:9000 ``` -Verify the deletion in the RustFS Console. +Prüfen Sie die Löschung in der RustFS-Console. diff --git a/content/de/administration/data/object/multipart-upload.md b/content/de/administration/data/object/multipart-upload.md index d4a6af66e..291edc9c3 100644 --- a/content/de/administration/data/object/multipart-upload.md +++ b/content/de/administration/data/object/multipart-upload.md @@ -1,79 +1,79 @@ --- -title: "Multipart Upload" -description: "Upload large objects in parts, monitor Console upload tasks, and verify completed objects with rc." +title: "Mehrteiliger Upload" +description: "Laden Sie große Objekte in Teilen hoch, überwachen Sie Upload-Aufgaben in der Console und prüfen Sie abgeschlossene Objekte mit rc." --- -Multipart upload splits one object into independently uploaded parts and assembles them on the server. Use it for large objects, retryable transfers, and browser uploads that need progress and cancellation controls. +Ein mehrteiliger Upload teilt ein Objekt in unabhängig hochgeladene Teile und setzt sie auf dem Server zusammen. Verwenden Sie ihn für große Objekte, wiederholbare Übertragungen und Browser-Uploads, die Fortschritt und Abbruch benötigen. -## Overview +## Überblick -The S3 multipart workflow has three required phases: +Der mehrteilige S3-Ablauf hat drei erforderliche Phasen: -1. **CreateMultipartUpload** returns an upload ID. -2. **UploadPart** uploads numbered parts and returns an ETag for each part. -3. **CompleteMultipartUpload** submits the ordered part numbers and ETags to create the final object. +1. **CreateMultipartUpload** gibt eine Upload-ID zurück. +2. **UploadPart** lädt nummerierte Teile hoch und gibt für jeden Teil ein ETag zurück. +3. **CompleteMultipartUpload** übermittelt die geordneten Teilnummern und ETags, um das endgültige Objekt zu erstellen. -Abort an unfinished upload with **AbortMultipartUpload** so temporary parts do not continue consuming storage. +Brechen Sie einen nicht abgeschlossenen Upload mit **AbortMultipartUpload** ab, damit temporäre Teile nicht weiter Speicher belegen. -RustFS accepts part numbers from `1` through `10000`. `ListParts` and `ListMultipartUploads` return at most 1,000 entries per response and use markers for pagination. The completed object appears only after the completion request succeeds. +RustFS akzeptiert Teilnummern von `1` bis `10000`. `ListParts` und `ListMultipartUploads` geben höchstens 1.000 Einträge je Antwort zurück und verwenden Marker für die Seitenaufteilung. Das abgeschlossene Objekt erscheint erst, nachdem die Abschlussanfrage erfolgreich war. -## Upload in the Console +## In der Console hochladen -1. Sign in to the RustFS Console and open the destination bucket. -2. Select **Upload File/Folder**. -3. Optionally enter a **Current Prefix**. -4. Select **Select File** or **Select Folder**, then choose the content to upload. -5. Review the selected names and sizes, then select **Start Upload**. +1. Melden Sie sich an der RustFS-Console an und öffnen Sie den Ziel-Bucket. +2. Wählen Sie **Upload File/Folder** (Datei oder Ordner hochladen). +3. Geben Sie optional ein **Current Prefix** (aktuelles Präfix) ein. +4. Wählen Sie **Select File** (Datei auswählen) oder **Select Folder** (Ordner auswählen) und wählen Sie anschließend den hochzuladenden Inhalt. +5. Prüfen Sie die ausgewählten Namen und Größen und wählen Sie dann **Start Upload** (Upload starten). -![Console upload dialog with a selected large file](./images/multipart-upload-console.png) +![Upload-Dialog der Console mit einer ausgewählten großen Datei](./images/multipart-upload-console.png) -The observed Console upload dialog supports up to 10,000 selected files and reports a 512 GB maximum for a single file. These are Console upload limits; S3 clients can have different local limits. +Der Upload-Dialog der Console unterstützt bis zu 10.000 Dateien und gibt für eine einzelne Datei ein Maximum von 512 GB an. Das sind Upload-Grenzen der Console. S3-Clients können andere lokale Grenzen haben. -After upload starts, **Task Management** groups tasks into Pending, Processing, Completed, Failed, and Canceled states. Each processing task shows progress and a **Cancel** action. Canceling an active multipart task aborts the current part request and marks the task as canceled. +Nachdem der Upload gestartet ist, gruppiert **Task Management** (Aufgabenverwaltung) die Aufgaben in die Zustände **Pending** (ausstehend), **Processing** (in Bearbeitung), **Completed** (abgeschlossen), **Failed** (fehlgeschlagen) und **Canceled** (abgebrochen). Jede laufende Aufgabe zeigt den Fortschritt und eine Aktion **Cancel** (Abbrechen). Wenn Sie eine aktive mehrteilige Aufgabe abbrechen, wird die aktuelle Teilanfrage abgebrochen und die Aufgabe als abgebrochen markiert. -Refresh the bucket after completion and confirm the object size and modification time. +Aktualisieren Sie den Bucket nach dem Abschluss und prüfen Sie Objektgröße und Änderungszeit. -## Use rc +## `rc` verwenden -Upload and verify an object with `rc`: +Laden Sie ein Objekt mit `rc` hoch und prüfen Sie es: ```bash rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt rc object stat rustfs/my-bucket/hello.txt --json ``` -:::note[rc 0.1.29 multipart boundary] +:::note[Grenzen des mehrteiligen Uploads in rc 0.1.29] -`rc 0.1.29` does not expose create, upload-part, complete, list-parts, or abort multipart commands. A validated 20 MiB `rc object copy` used a single `PutObject` request rather than multipart upload. Use the Console or an S3 SDK when explicit multipart behavior is required; use `rc object stat` to verify the completed object. +`rc 0.1.29` stellt keine Befehle zum Erstellen, Hochladen von Teilen, Abschließen, Auflisten von Teilen oder Abbrechen eines mehrteiligen Uploads bereit. Ein geprüfter `rc object copy` von 20 MiB verwendete eine einzelne `PutObject`-Anfrage und keinen mehrteiligen Upload. Verwenden Sie die Console oder ein S3-SDK, wenn ausdrückliches mehrteiliges Verhalten erforderlich ist. Prüfen Sie das abgeschlossene Objekt mit `rc object stat`. ::: -For a versioned bucket, list the version created by a completed multipart upload: +Listen Sie bei einem versionierten Bucket die Version auf, die ein abgeschlossener mehrteiliger Upload erzeugt hat: ```bash rc bucket version list rustfs/my-bucket/hello.txt --json ``` -RustFS returns a version ID when multipart completion succeeds in a versioned bucket. +RustFS gibt eine Versions-ID zurück, wenn der Abschluss eines mehrteiligen Uploads in einem versionierten Bucket erfolgreich ist. -## S3 multipart operations +## Mehrteilige S3-Operationen -Use an S3 SDK that supports these standard operations: +Verwenden Sie ein S3-SDK, das diese Standardoperationen unterstützt: -| Phase | S3 operation | Required values | +| Phase | S3-Operation | Erforderliche Werte | | --- | --- | --- | -| Initiate | `CreateMultipartUpload` | Bucket, key, metadata, encryption, and optional Object Lock settings. | -| Upload | `UploadPart` | Bucket, key, upload ID, part number, and body. Save the returned ETag. | -| Inspect | `ListParts` | Bucket, key, and upload ID. Paginate when needed. | -| Complete | `CompleteMultipartUpload` | Ordered part numbers and their exact ETags. | -| Cancel | `AbortMultipartUpload` | Bucket, key, and upload ID. | -| Discover | `ListMultipartUploads` | Bucket and optional prefix. Paginate when needed. | +| Starten | `CreateMultipartUpload` | Bucket, Objektschlüssel, Metadaten, Verschlüsselung und optionale Object-Lock-Einstellungen. | +| Hochladen | `UploadPart` | Bucket, Objektschlüssel, Upload-ID, Teilnummer und Inhalt. Speichern Sie das zurückgegebene ETag. | +| Prüfen | `ListParts` | Bucket, Objektschlüssel und Upload-ID. Blättern Sie bei Bedarf durch die Seiten. | +| Abschließen | `CompleteMultipartUpload` | Geordnete Teilnummern und ihre genauen ETags. | +| Abbrechen | `AbortMultipartUpload` | Bucket, Objektschlüssel und Upload-ID. | +| Auffinden | `ListMultipartUploads` | Bucket und optionales Präfix. Blättern Sie bei Bedarf durch die Seiten. | -Do not reuse an upload ID for a different key. Submit completed parts in ascending part-number order and preserve each ETag exactly as returned. +Verwenden Sie eine Upload-ID nicht für einen anderen Objektschlüssel. Übermitteln Sie abgeschlossene Teile in aufsteigender Teilnummernreihenfolge und behalten Sie jedes ETag genau so bei, wie es zurückgegeben wurde. -## Verification +## Überprüfung -After completion: +Nach dem Abschluss: ```bash rc object stat rustfs/my-bucket/hello.txt --json @@ -81,21 +81,21 @@ rc object show rustfs/my-bucket/hello.txt > /tmp/hello-downloaded.txt cmp /path/to/hello.txt /tmp/hello-downloaded.txt ``` -Confirm that `size_bytes` matches the local file and that `cmp` exits successfully. For a versioned bucket, also confirm that `rc bucket version list` returns a version ID. +Prüfen Sie, dass `size_bytes` mit der lokalen Datei übereinstimmt und dass `cmp` erfolgreich beendet wird. Bestätigen Sie bei einem versionierten Bucket zusätzlich, dass `rc bucket version list` eine Versions-ID zurückgibt. -## Troubleshooting +## Fehlerbehebung -| Symptom | Check | +| Symptom | Prüfung | | --- | --- | -| Upload remains in Processing | Check browser connectivity and keep the Console tab open; cancel and retry when the connection is interrupted. | -| A part request fails | Retry that part with the same upload ID and part number, then use the latest returned ETag. | -| Completion reports an invalid part | Verify the submitted part numbers, ordering, and ETags against `ListParts`. | -| Object is absent after uploading parts | Send `CompleteMultipartUpload`; uploaded parts alone do not create the object. | -| Temporary storage continues growing | List incomplete uploads and abort those that are no longer needed. | -| Completion fails on a locked key | Check Object Lock retention or Legal Hold on the current destination version. | - -## Next steps - -- [Create and inspect objects](./creation.md) -- [Manage object versions](./versioning.md) -- [Protect objects with Object Lock](./object-lock.md) \ No newline at end of file +| Der Upload bleibt in **Processing** | Prüfen Sie die Browserverbindung und lassen Sie die Registerkarte der Console geöffnet. Brechen Sie ab und wiederholen Sie den Upload, wenn die Verbindung unterbrochen wird. | +| Eine Teilanfrage schlägt fehl | Wiederholen Sie diesen Teil mit derselben Upload-ID und Teilnummer und verwenden Sie anschließend das zuletzt zurückgegebene ETag. | +| Der Abschluss meldet einen ungültigen Teil | Prüfen Sie die übermittelten Teilnummern, die Reihenfolge und die ETags gegen `ListParts`. | +| Das Objekt fehlt nach dem Hochladen der Teile | Senden Sie `CompleteMultipartUpload`. Hochgeladene Teile allein erstellen das Objekt nicht. | +| Der temporäre Speicher wächst weiter | Listen Sie unvollständige Uploads auf und brechen Sie diejenigen ab, die nicht mehr benötigt werden. | +| Der Abschluss schlägt bei einem gesperrten Objektschlüssel fehl | Prüfen Sie die Object-Lock-Aufbewahrung oder den Legal Hold der aktuellen Zielversion. | + +## Nächste Schritte + +- [Objekte erstellen und anzeigen](./creation.md) +- [Objektversionen verwalten](./versioning.md) +- [Objekte mit Object Lock schützen](./object-lock.md) diff --git a/content/de/administration/data/object/object-lock.md b/content/de/administration/data/object/object-lock.md index 5db3468a1..d4dcab9c8 100644 --- a/content/de/administration/data/object/object-lock.md +++ b/content/de/administration/data/object/object-lock.md @@ -1,46 +1,46 @@ --- title: "Object Lock" -description: "Protect versioned objects from deletion with retention periods and legal holds." +description: "Schützen Sie versionierte Objekte mit Aufbewahrungszeiträumen und Legal Holds vor dem Löschen." --- -RustFS Object Lock applies write-once, read-many protection to individual object versions. Use retention periods for time-bound protection and Legal Hold for protection without a predefined expiration date. +Object Lock von RustFS schützt einzelne Objektversionen nach dem Prinzip Write once, read many. Verwenden Sie Aufbewahrungszeiträume für einen zeitlich begrenzten Schutz und Legal Hold für einen Schutz ohne vorgegebenes Ablaufdatum. -## Overview +## Überblick -Object Lock requires bucket versioning. You can enable it when creating a bucket or use the S3 `PutObjectLockConfiguration` API on an existing bucket whose versioning is enabled. Each overwrite creates a new version; retention and Legal Hold protect a specific version rather than the object key as a whole. +Object Lock erfordert die Bucket-Versionierung. Sie können es beim Erstellen eines Buckets aktivieren oder die S3-API `PutObjectLockConfiguration` für einen vorhandenen Bucket verwenden, dessen Versionierung aktiviert ist. Jede Überschreibung erzeugt eine neue Version. Aufbewahrung und Legal Hold schützen eine bestimmte Version und nicht den Objektschlüssel als Ganzes. -| Protection | Behavior | +| Schutz | Verhalten | | --- | --- | -| `GOVERNANCE` retention | Blocks deletion and retention shortening unless the caller has bypass permission and explicitly requests a bypass. Retention can be extended without bypass. | -| `COMPLIANCE` retention | Blocks deletion even with governance bypass. The date can be extended but not shortened. | -| Legal Hold | Blocks deletion until the hold is set to `OFF`. It has no expiration date and governance bypass does not override it. | +| `GOVERNANCE`-Aufbewahrung | Blockiert das Löschen und das Verkürzen der Aufbewahrung, es sei denn, der Aufrufer hat die Bypass-Berechtigung und fordert einen Bypass ausdrücklich an. Die Aufbewahrung kann ohne Bypass verlängert werden. | +| `COMPLIANCE`-Aufbewahrung | Blockiert das Löschen auch mit Governance-Bypass. Das Datum kann verlängert, aber nicht verkürzt werden. | +| Legal Hold | Blockiert das Löschen, bis der Hold auf `OFF` gesetzt wird. Er hat kein Ablaufdatum, und ein Governance-Bypass setzt ihn nicht außer Kraft. | -Deleting a key without a version ID creates a delete marker. The protected version remains stored and can still be retrieved by version ID. +Das Löschen eines Objektschlüssels ohne Versions-ID erzeugt einen Löschmarker. Die geschützte Version bleibt gespeichert und kann weiterhin über die Versions-ID abgerufen werden. -:::danger[Plan retention before enabling it] +:::danger[Planen Sie die Aufbewahrung, bevor Sie sie aktivieren] -COMPLIANCE retention cannot be bypassed or shortened before its retain-until date. Test policies in a non-production bucket and verify time synchronization, permissions, lifecycle rules, replication, and backup procedures before protecting production data. +Die COMPLIANCE-Aufbewahrung kann vor dem Retain-until-Datum weder umgangen noch verkürzt werden. Testen Sie Richtlinien in einem Bucket außerhalb der Produktion und prüfen Sie Zeitsynchronisation, Berechtigungen, Lebenszyklusregeln, Replikation und Sicherungsverfahren, bevor Sie Produktionsdaten schützen. ::: -## Configure in the Console +## In der Console konfigurieren -1. Sign in to the RustFS Console and open **Buckets**. -2. Select **Create Bucket** and enter the bucket name. -3. Enable **Object Lock**. The Console also enables **Version** because Object Lock requires versioning. -4. To apply retention automatically to new object versions, enable **Retention**. -5. Select **COMPLIANCE** or **GOVERNANCE**, enter the validity, and select **Day** or **Year**. -6. Select **Create**. +1. Melden Sie sich an der RustFS-Console an und öffnen Sie **Buckets**. +2. Wählen Sie **Create Bucket** (Bucket erstellen) und geben Sie den Bucket-Namen ein. +3. Aktivieren Sie **Object Lock**. Die Console aktiviert zusätzlich **Version** (Versionierung), weil Object Lock Versionierung erfordert. +4. Aktivieren Sie **Retention** (Aufbewahrung), wenn die Aufbewahrung automatisch auf neue Objektversionen angewendet werden soll. +5. Wählen Sie **COMPLIANCE** oder **GOVERNANCE**, geben Sie den Aufbewahrungszeitraum ein und wählen Sie **Day** (Tag) oder **Year** (Jahr). +6. Wählen Sie **Create** (Erstellen). -![Create Bucket dialog with versioning, Object Lock, and default retention enabled](./images/object-lock-create-bucket.png) +![Dialog Bucket erstellen mit aktivierter Versionierung, Object Lock und Standardaufbewahrung](./images/object-lock-create-bucket.png) -The Console initially displays `180` days when default retention is enabled. Replace it with the period required by your retention policy; it is a UI initial value, not a general recommendation. +Die Console zeigt anfangs `180` Tage an, wenn die Standardaufbewahrung aktiviert ist. Ersetzen Sie den Wert durch den Zeitraum, den Ihre Aufbewahrungsrichtlinie verlangt. Es handelt sich um einen Anfangswert der Oberfläche und nicht um eine allgemeine Empfehlung. -To inspect a protected object, open the bucket, select the object name, and use the **Versions** and **Info** tabs. The Info tab exposes **Legal Hold** and **RetentionPolicy** fields. +Um ein geschütztes Objekt anzuzeigen, öffnen Sie den Bucket, wählen Sie den Objektnamen und verwenden Sie die Registerkarten **Versions** (Versionen) und **Info**. Die Registerkarte Info zeigt die Felder **Legal Hold** und **RetentionPolicy**. -## Use rc +## `rc` verwenden -Configure an alias before running these examples: +Konfigurieren Sie einen Alias, bevor Sie diese Beispiele ausführen: ```bash rc alias set rustfs http://localhost:9000 \ @@ -48,13 +48,13 @@ rc alias set rustfs http://localhost:9000 \ --region us-east-1 --bucket-lookup path ``` -:::note[rc 0.1.29 bucket creation boundary] +:::note[Grenze beim Erstellen von Buckets in rc 0.1.29] -`rc bucket create --with-lock` and `--with-versioning` appear in the `rc 0.1.29` help output but return `not implemented` when executed. Create the Object Lock bucket in the Console. The upload headers shown below are supported and were validated against RustFS. +`rc bucket create --with-lock` und `--with-versioning` erscheinen in der Hilfe von `rc 0.1.29`, geben bei der Ausführung aber `not implemented` zurück. Erstellen Sie den Object-Lock-Bucket in der Console. Die unten gezeigten Upload-Header werden unterstützt und wurden gegen RustFS geprüft. ::: -Upload an object version with GOVERNANCE retention. Supply both retention headers together and use an RFC 3339 UTC timestamp in the future: +Laden Sie eine Objektversion mit GOVERNANCE-Aufbewahrung hoch. Geben Sie beide Aufbewahrungsheader zusammen an und verwenden Sie einen RFC-3339-Zeitstempel in UTC in der Zukunft: ```bash rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt \ @@ -62,14 +62,14 @@ rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt \ -H "x-amz-object-lock-retain-until-date:2027-01-01T00:00:00Z" ``` -Upload an object version with Legal Hold enabled: +Laden Sie eine Objektversion mit aktiviertem Legal Hold hoch: ```bash rc object copy /path/to/hello.txt rustfs/my-bucket/legal-hold.txt \ -H "x-amz-object-lock-legal-hold:ON" ``` -List the protected versions and inspect a specific version: +Listen Sie die geschützten Versionen auf und rufen Sie die Metadaten einer bestimmten Version ab (Head): ```bash rc bucket version list rustfs/my-bucket --json @@ -77,27 +77,27 @@ rc object stat rustfs/my-bucket/hello.txt \ --version-id --json ``` -`rc 0.1.29` does not provide commands to change retention or switch an existing Legal Hold between `ON` and `OFF`. Use the Console or an S3 SDK for those operations. +`rc 0.1.29` bietet keine Befehle, um die Aufbewahrung zu ändern oder einen vorhandenen Legal Hold zwischen `ON` und `OFF` umzuschalten. Verwenden Sie dafür die Console oder ein S3-SDK. -## Verify protection +## Schutz prüfen -1. Upload a test object with GOVERNANCE retention or Legal Hold. -2. Record its version ID with `rc bucket version list`. -3. Attempt to delete that exact version through an S3 client without bypass. RustFS must return `AccessDenied` while protection is active. -4. Confirm the version remains visible in the Console and through `rc object stat --version-id`. +1. Laden Sie ein Testobjekt mit GOVERNANCE-Aufbewahrung oder Legal Hold hoch. +2. Notieren Sie seine Versions-ID mit `rc bucket version list`. +3. Versuchen Sie, genau diese Version über einen S3-Client ohne Bypass zu löschen. RustFS muss `AccessDenied` zurückgeben, solange der Schutz aktiv ist. +4. Prüfen Sie, dass die Version in der Console und über `rc object stat --version-id` sichtbar bleibt. -For GOVERNANCE retention, test bypass only with a dedicated administrative identity that has `s3:BypassGovernanceRetention`. COMPLIANCE retention and Legal Hold remain protected from governance bypass. +Testen Sie den Bypass bei GOVERNANCE-Aufbewahrung nur mit einer eigenen administrativen Identität, die `s3:BypassGovernanceRetention` besitzt. COMPLIANCE-Aufbewahrung und Legal Hold bleiben vor einem Governance-Bypass geschützt. -## Operational considerations +## Betriebliche Hinweise -- Default bucket retention is calculated when a new object version or multipart upload is initiated. -- Copying an object creates a new destination version; destination retention policy applies independently. -- Suspending versioning is not appropriate for an Object Lock bucket. -- Lifecycle expiration cannot remove a version while retention or Legal Hold blocks deletion. -- Replication targets for locked objects must support compatible Object Lock behavior. +- Die Standardaufbewahrung des Buckets wird berechnet, wenn eine neue Objektversion oder ein mehrteiliger Upload begonnen wird. +- Das Kopieren eines Objekts erzeugt eine neue Zielversion. Die Aufbewahrungsrichtlinie des Ziels gilt unabhängig. +- Das Aussetzen der Versionierung ist für einen Object-Lock-Bucket nicht geeignet. +- Der Lebenszyklusablauf kann eine Version nicht entfernen, solange Aufbewahrung oder Legal Hold das Löschen blockieren. +- Replikationsziele für gesperrte Objekte müssen ein kompatibles Object-Lock-Verhalten unterstützen. -## Next steps +## Nächste Schritte -- [Manage object versions](./versioning.md) -- [Configure bucket replication](../bucket/replication.md) -- [Review the security checklist](/installation/requirement/checklists/security-checklists) \ No newline at end of file +- [Objektversionen verwalten](./versioning.md) +- [Bucket-Replikation konfigurieren](../bucket/replication.md) +- [Sicherheitscheckliste prüfen](/de/installation/requirement/checklists/security-checklists) diff --git a/content/de/administration/data/object/scanner.md b/content/de/administration/data/object/scanner.md index 6330c38f6..d5d1ea25f 100644 --- a/content/de/administration/data/object/scanner.md +++ b/content/de/administration/data/object/scanner.md @@ -1,32 +1,32 @@ --- -title: "Object Scanning" -description: "Guide to the RustFS object scanner, including design, implementation, and monitoring." +title: "Objekt-Scan" +description: "Beschreibt den Objekt-Scanner von RustFS, einschließlich Entwurf, Implementierung und Überwachung." --- -This guide covers the design and implementation of the RustFS object scanner, including its integration with Erasure Coding, Scrub & Repair mechanisms, scheduling strategies, monitoring metrics, and troubleshooting. +Diese Anleitung beschreibt Entwurf und Implementierung des Objekt-Scanners von RustFS, einschließlich des Zusammenspiels mit Erasure Coding, der Prüfung und Reparatur, der Planung, der Metriken und der Fehlerbehebung. -## Overview +## Überblick -The RustFS object scanner is built into the storage engine and is responsible for periodically checking object integrity and executing scheduled operations. -Scanning tasks include disk usage statistics, lifecycle management rule evaluation, object replication execution, and triggering corrupted object self-healing. +Der Objekt-Scanner von RustFS ist in die Speicher-Engine eingebaut. Er prüft regelmäßig die Integrität von Objekten und führt geplante Operationen aus. +Der Scanner erfasst Statistiken zur Datenträgernutzung, wertet Lebenszyklusregeln aus, führt die Objektreplikation aus und löst die Datenwiederherstellung (Healing) für beschädigte Objekte aus. -## Architecture and Design Principles +## Architektur und Entwurfsprinzipien -### Scanner Architecture +### Scanner-Architektur -The RustFS scanner uses a hash sampling mechanism, selecting one out of every 1024 objects for inspection based on object name hashing to minimize performance impact. -The scanner is deeply integrated with the Erasure Coding module, utilizing redundant shards for online reconstruction when detecting lost or corrupted shards, ensuring high data availability and consistency. +Der Scanner von RustFS verwendet eine Hash-Stichprobe. Anhand des Hashs des Objektnamens wählt er jedes 1024. Objekt für eine Prüfung aus, um die Auswirkung auf die Leistung gering zu halten. +Der Scanner arbeitet mit dem Erasure Coding: Erkennt er ein fehlendes oder beschädigtes Shard, baut er das Shard online aus den verbleibenden redundanten Shards wieder auf. -## Data Verification and Recovery +## Datenprüfung und Wiederherstellung -The RustFS data verification mechanism checks metadata consistency and performs bit-by-bit reading and verification to discover hidden bad blocks. The object scanner detects issues like bit rot and triggers repair processes when necessary. +Die Datenprüfung von RustFS prüft die Konsistenz der Metadaten und liest Daten, um sie zu prüfen und latente defekte Sektoren zu erkennen. Der Objekt-Scanner erkennt Probleme wie Bit Rot und stößt bei Bedarf Reparaturvorgänge an. -## Scanning Modes and Scheduling +## Scan-Modi und Planung -RustFS supports three scanning modes: online scanning during reads, background periodic scanning, and manual full scanning, balancing performance and reliability. -Similar to the `osd_scrub_begin_hour` configuration in Ceph, administrators can set scanning start times and frequency. For example, light verification is set to once daily by default. +RustFS unterstützt drei Scan-Modi, die Leistung und Zuverlässigkeit ausbalancieren: Prüfungen während des Lesens, regelmäßige Hintergrundscans und manuelle vollständige Scans. +Ähnlich wie bei der Ceph-Einstellung `osd_scrub_begin_hour` können Sie Startzeitpunkt und Häufigkeit der Scans festlegen. Eine leichte Prüfung läuft beispielsweise standardmäßig einmal täglich. -## Monitoring and Metrics +## Überwachung und Metriken -Scanner statistics include total task count, failure count, and time distribution, exposing metrics through the Prometheus data model such as `rustfs_scanner_jobs_total`, `rustfs_scanner_failures_total`, and `rustfs_scanner_duration_seconds`. -Combined with monitoring systems, alerts can be set based on scanning failure rates and duration to promptly discover and locate potential issues at the storage or network levels. \ No newline at end of file +Der Scanner meldet die Gesamtzahl der Aufgaben, die Anzahl der Fehler und die Verteilung der Dauer als Prometheus-Metriken, etwa `rustfs_scanner_jobs_total`, `rustfs_scanner_failures_total` und `rustfs_scanner_duration_seconds`. +Konfigurieren Sie Alarme für die Fehlerrate und die Dauer der Scans, damit Sie Speicher- oder Netzwerkprobleme früh erkennen und eingrenzen können. diff --git a/content/de/administration/data/object/versioning.md b/content/de/administration/data/object/versioning.md index b891c7567..09570e8a4 100644 --- a/content/de/administration/data/object/versioning.md +++ b/content/de/administration/data/object/versioning.md @@ -1,48 +1,48 @@ --- -title: "Versioning" -description: "Enable bucket versioning, recover earlier object versions, and manage delete markers with rc and the Console." +title: "Versionierung" +description: "Aktivieren Sie die Bucket-Versionierung, stellen Sie frühere Objektversionen wieder her und verwalten Sie Löschmarker mit rc und der Console." --- -RustFS bucket versioning preserves multiple versions of the same object key. Use it to recover from accidental overwrites and deletes and to satisfy prerequisites for Object Lock and bucket replication. +Die Bucket-Versionierung von RustFS bewahrt mehrere Versionen desselben Objektschlüssels auf. Damit stellen Sie versehentliche Überschreibungen und Löschungen wieder her und erfüllen Voraussetzungen für Object Lock und die Bucket-Replikation. -## Overview +## Überblick -When versioning is enabled: +Wenn die Versionierung aktiviert ist: -- Each upload or copy to an existing key creates a new version ID. -- A normal delete creates a delete marker instead of removing older versions. -- Reading the key without a version ID returns the latest visible version, or `NotFound` when the latest entry is a delete marker. -- Reading or deleting a specific version requires its version ID. +- Jeder Upload oder jede Kopie auf einen vorhandenen Objektschlüssel erzeugt eine neue Versions-ID. +- Ein normales Löschen erzeugt einen Löschmarker, anstatt ältere Versionen zu entfernen. +- Das Lesen des Objektschlüssels ohne Versions-ID gibt die letzte sichtbare Version zurück oder `NotFound`, wenn der letzte Eintrag ein Löschmarker ist. +- Das Lesen oder Löschen einer bestimmten Version erfordert ihre Versions-ID. -Suspending versioning stops normal creation of new version IDs but preserves existing versions and delete markers. Suspension is not the same as disabling or removing version history. +Das Aussetzen der Versionierung beendet das normale Erzeugen neuer Versions-IDs, bewahrt aber vorhandene Versionen und Löschmarker. Aussetzen ist nicht dasselbe wie das Deaktivieren oder Entfernen der Versionshistorie. -## Configure in the Console +## In der Console konfigurieren -### Enable at bucket creation +### Beim Erstellen des Buckets aktivieren -1. Open **Buckets** and select **Create Bucket**. -2. Enter the bucket name. -3. Enable **Version**. -4. Select **Create**. +1. Öffnen Sie **Buckets** und wählen Sie **Create Bucket** (Bucket erstellen). +2. Geben Sie den Bucket-Namen ein. +3. Aktivieren Sie **Version** (Versionierung). +4. Wählen Sie **Create** (Erstellen). -### Enable or suspend an existing bucket +### Versionierung eines vorhandenen Buckets aktivieren oder aussetzen -1. Open **Buckets**, locate the bucket, and select **Settings**. -2. Under **Data Protection**, locate **Versioning**. -3. Enable versioning or suspend it as required. +1. Öffnen Sie **Buckets**, suchen Sie den Bucket und wählen Sie **Settings** (Einstellungen). +2. Suchen Sie unter **Data Protection** (Datenschutz) den Eintrag **Versioning** (Versionierung). +3. Aktivieren Sie die Versionierung oder setzen Sie sie nach Bedarf aus. -The settings page reports `Enabled`, `Suspended`, or `Disabled`. It also notes that suspension preserves existing versions. +Die Einstellungsseite meldet `Enabled`, `Suspended` oder `Disabled`. Sie weist außerdem darauf hin, dass das Aussetzen vorhandene Versionen bewahrt. -### Browse and recover versions +### Versionen durchsuchen und wiederherstellen -1. Open the bucket and enable **Show Deleted Objects** when you need to see keys hidden by delete markers. -2. Select an object name to open **Object Details**. -3. Select **Versions** to inspect available versions and delete markers. -4. Download the required version and upload it again to make its content the latest version. +1. Öffnen Sie den Bucket und aktivieren Sie **Show Deleted Objects** (Gelöschte Objekte anzeigen), wenn Sie Objektschlüssel sehen müssen, die durch Löschmarker verborgen sind. +2. Wählen Sie einen Objektnamen, um **Object Details** (Objektdetails) zu öffnen. +3. Wählen Sie **Versions** (Versionen), um verfügbare Versionen und Löschmarker anzuzeigen. +4. Laden Sie die benötigte Version herunter und laden Sie sie erneut hoch, damit ihr Inhalt die neueste Version wird. -## Use rc +## `rc` verwenden -Create a bucket and enable versioning: +Erstellen Sie einen Bucket und aktivieren Sie die Versionierung: ```bash rc bucket create rustfs/my-bucket @@ -50,7 +50,7 @@ rc bucket version enable rustfs/my-bucket rc bucket version info rustfs/my-bucket ``` -Upload two versions of the same key: +Laden Sie zwei Versionen desselben Objektschlüssels hoch: ```bash printf 'version one\n' > /tmp/hello.txt @@ -60,7 +60,7 @@ printf 'version two\n' > /tmp/hello.txt rc object copy /tmp/hello.txt rustfs/my-bucket/hello.txt --overwrite ``` -List versions and record the version ID you want to recover: +Listen Sie die Versionen auf und notieren Sie die Versions-ID, die Sie wiederherstellen möchten: ```bash rc bucket version list rustfs/my-bucket/hello.txt --json @@ -68,7 +68,7 @@ rc object stat rustfs/my-bucket/hello.txt \ --version-id --json ``` -Restore an earlier version by downloading its body and uploading it as a new latest version: +Stellen Sie eine frühere Version wieder her, indem Sie ihren Inhalt herunterladen und als neue neueste Version hochladen: ```bash rc object show rustfs/my-bucket/hello.txt \ @@ -78,48 +78,48 @@ rc object copy /tmp/hello-restored.txt \ rustfs/my-bucket/hello.txt --overwrite ``` -Delete the current key to create a delete marker, then inspect it: +Löschen Sie den aktuellen Objektschlüssel, um einen Löschmarker zu erzeugen, und zeigen Sie ihn anschließend an: ```bash rc object remove rustfs/my-bucket/hello.txt --force rc bucket version list rustfs/my-bucket/hello.txt --json ``` -The latest entry should show `is_delete_marker: true`. The earlier versions remain available by version ID. +Der neueste Eintrag sollte `is_delete_marker: true` anzeigen. Die früheren Versionen bleiben über die Versions-ID verfügbar. -Suspend versioning when you no longer want normal writes to create new numbered versions: +Setzen Sie die Versionierung aus, wenn normale Schreibvorgänge keine neuen nummerierten Versionen mehr erzeugen sollen: ```bash rc bucket version suspend rustfs/my-bucket rc bucket version info rustfs/my-bucket ``` -:::warning[rc 0.1.29 version deletion boundary] +:::warning[Grenze beim Löschen von Versionen in rc 0.1.29] -`rc object remove --versions` is listed in the `rc 0.1.29` help output but returns `not implemented`. Use the Console or an S3 SDK to permanently delete selected version IDs. Do not remove an entire version history unless you have verified retention, replication, and recovery requirements. +`rc object remove --versions` steht in der Hilfe von `rc 0.1.29`, gibt bei der Ausführung aber `not implemented` zurück. Verwenden Sie die Console oder ein S3-SDK, um ausgewählte Versions-IDs dauerhaft zu löschen. Entfernen Sie eine vollständige Versionshistorie nur, wenn Sie Aufbewahrung, Replikation und Wiederherstellungsanforderungen geprüft haben. ::: -## Verification +## Überprüfung -After enabling versioning: +Nachdem Sie die Versionierung aktiviert haben: -1. Upload the same key twice with different content. -2. Run `rc bucket version list` and confirm that both entries have distinct version IDs. -3. Retrieve each version with `rc object show --version-id` and compare its content. -4. Delete the key without a version ID and confirm that a delete marker appears. -5. Retrieve an older version by version ID to confirm it remains recoverable. +1. Laden Sie denselben Objektschlüssel zweimal mit unterschiedlichem Inhalt hoch. +2. Führen Sie `rc bucket version list` aus und prüfen Sie, dass beide Einträge unterschiedliche Versions-IDs haben. +3. Rufen Sie jede Version mit `rc object show --version-id` ab und vergleichen Sie den Inhalt. +4. Löschen Sie den Objektschlüssel ohne Versions-ID und prüfen Sie, dass ein Löschmarker erscheint. +5. Rufen Sie eine ältere Version über die Versions-ID ab, um zu bestätigen, dass sie wiederherstellbar bleibt. -## Operational considerations +## Betriebliche Hinweise -- Versioning increases storage use because overwrites and deletes retain older data. -- Configure lifecycle rules for noncurrent versions only after defining recovery and retention periods. -- Bucket replication requires versioning on both source and destination buckets. -- Object Lock depends on versioning and protects individual versions. -- Multipart completion creates one new object version in a versioned bucket. +- Die Versionierung erhöht den Speicherverbrauch, weil Überschreibungen und Löschungen ältere Daten behalten. +- Konfigurieren Sie Lebenszyklusregeln für nicht aktuelle Versionen erst, nachdem Sie Wiederherstellungs- und Aufbewahrungszeiträume festgelegt haben. +- Die Bucket-Replikation erfordert Versionierung auf dem Quell- und auf dem Ziel-Bucket. +- Object Lock setzt Versionierung voraus und schützt einzelne Versionen. +- Der Abschluss eines mehrteiligen Uploads erzeugt in einem versionierten Bucket eine neue Objektversion. -## Next steps +## Nächste Schritte -- [Protect versions with Object Lock](./object-lock.md) -- [Upload large objects](./multipart-upload.md) -- [Manage bucket lifecycle](../lifecycle-management.md) \ No newline at end of file +- [Versionen mit Object Lock schützen](./object-lock.md) +- [Große Objekte hochladen](./multipart-upload.md) +- [Bucket-Lebenszyklus verwalten](../lifecycle-management.md) diff --git a/content/de/administration/data/tiered-storage.md b/content/de/administration/data/tiered-storage.md index d36257683..7c5391cb1 100644 --- a/content/de/administration/data/tiered-storage.md +++ b/content/de/administration/data/tiered-storage.md @@ -1,11 +1,11 @@ --- -title: "Tiered Storage" -description: "Configure lifecycle-driven object transitions from RustFS to a remote storage tier." +title: "Gestufte Speicherung" +description: "Konfigurieren Sie lebenszyklusgesteuerte Objektübergänge von RustFS zu einer entfernten Speicherstufe." --- -RustFS tiered storage moves objects from local storage to a configured remote backend. This page explains the supported targets and shows how to add and maintain a RustFS tier in the Console. +Die gestufte Speicherung von RustFS verschiebt Objekte aus dem lokalen Speicher in ein konfiguriertes entferntes Backend. Diese Seite erklärt die unterstützten Ziele und zeigt, wie Sie eine RustFS-Stufe in der Console hinzufügen und pflegen. -Tiering is asynchronous. RustFS keeps the object metadata locally, transfers the object data to the remote tier, and continues to serve S3 reads through the original bucket and object key. +Die Übertragung in die entfernte Stufe erfolgt asynchron. RustFS behält die Objektmetadaten lokal, überträgt die Objektdaten in die entfernte Stufe und bedient S3-Lesevorgänge weiterhin über den ursprünglichen Bucket und Objektschlüssel. ```mermaid flowchart LR @@ -14,22 +14,22 @@ flowchart LR H -->|Read transitioned object| T ``` -:::note[Tier names are not AWS storage classes] +:::note[Stufennamen sind keine AWS-Speicherklassen] -Lifecycle rules refer to a registered tier by its uppercase name, such as `COLDTIER`. Do not substitute AWS class labels such as `INTELLIGENT_TIERING`, `GLACIER`, or `DEEP_ARCHIVE` unless you have registered a RustFS tier with that exact valid name and verified the target behavior. +Lebenszyklusregeln verweisen auf eine registrierte Stufe über ihren Namen in Großbuchstaben, etwa `COLDTIER`. Ersetzen Sie ihn nicht durch AWS-Klassenbezeichnungen wie `INTELLIGENT_TIERING`, `GLACIER` oder `DEEP_ARCHIVE`, es sei denn, Sie haben eine RustFS-Stufe mit genau diesem gültigen Namen registriert und das Zielverhalten geprüft. ::: -## Supported backends +## Unterstützte Backends -The RustFS source defines warm-backend implementations for these target types: +Der RustFS-Quellcode definiert Warm-Backend-Implementierungen für diese Zieltypen: -| Type | Configuration key | Typical target | +| Typ | Konfigurationsschlüssel | Typisches Ziel | | --- | --- | --- | -| RustFS | `rustfs` | Another RustFS deployment | -| S3 | `s3` | Amazon S3 or an S3 endpoint supported by this backend | -| Wasabi | `wasabi` | Wasabi object storage | -| MinIO | `minio` | A MinIO deployment | +| RustFS | `rustfs` | Eine andere RustFS-Bereitstellung | +| S3 | `s3` | Amazon S3 oder ein von diesem Backend unterstützter S3-Endpunkt | +| Wasabi | `wasabi` | Wasabi-Objektspeicher | +| MinIO | `minio` | Eine MinIO-Bereitstellung | | Aliyun | `aliyun` | Alibaba Cloud Object Storage Service (OSS) | | Tencent | `tencent` | Tencent Cloud Object Storage (COS) | | Huaweicloud | `huaweicloud` | Huawei Cloud Object Storage Service (OBS) | @@ -37,64 +37,64 @@ The RustFS source defines warm-backend implementations for these target types: | GCS | `gcs` | Google Cloud Storage | | R2 | `r2` | Cloudflare R2 | -Provider payloads and credential requirements differ. The complete workflow below uses the RustFS backend because the RustFS source includes an end-to-end hot-cluster-to-cold-cluster test for this path. +Die Konfigurationsdaten der Anbieter und die Anforderungen an die Zugangsdaten unterscheiden sich. Der vollständige Ablauf unten verwendet das RustFS-Backend, weil der RustFS-Quellcode für diesen Pfad einen Ende-zu-Ende-Test vom heißen Cluster zum kalten Cluster enthält. -## Before you begin +## Bevor Sie beginnen -Prepare the following: +Bereiten Sie Folgendes vor: -- A source RustFS deployment that stores the hot data. -- A separate target RustFS deployment and an existing target bucket. This example uses `my-bucket` on the target. -- Target credentials with permission to put, get, list, and delete objects in that bucket. -- Access to the source deployment's RustFS Console. +- Eine RustFS-Quellbereitstellung, die die heißen Daten speichert. +- Eine separate RustFS-Zielbereitstellung und einen vorhandenen Ziel-Bucket. Dieses Beispiel verwendet `my-bucket` auf dem Ziel. +- Ziel-Zugangsdaten mit der Berechtigung, Objekte in diesem Bucket zu schreiben, zu lesen, aufzulisten und zu löschen. +- Zugriff auf die RustFS-Console der Quellbereitstellung. -Use TLS for both deployments in production. Restrict the target credentials to the dedicated tier bucket and prefix. +Verwenden Sie in der Produktion TLS für beide Bereitstellungen. Beschränken Sie die Ziel-Zugangsdaten auf den dedizierten Stufen-Bucket und das Präfix. -## 1. Open Tiered Storage +## 1. Gestufte Speicherung öffnen -Sign in to the source deployment's RustFS Console. In the left navigation, select **Tiered Storage**, then select **Add Tier** in the upper-right corner. +Melden Sie sich an der RustFS-Console der Quellbereitstellung an. Wählen Sie in der linken Navigation **Tiered Storage** (gestufte Speicherung) und anschließend oben rechts **Add Tier** (Stufe hinzufügen). -## 2. Select the target +## 2. Ziel auswählen -Select the target provider. This example uses **RustFS** to connect the source deployment to another RustFS deployment. +Wählen Sie den Zielanbieter. Dieses Beispiel verwendet **RustFS**, um die Quellbereitstellung mit einer anderen RustFS-Bereitstellung zu verbinden. -## 3. Enter the target details +## 3. Zieldetails eingeben -Complete the form: +Füllen Sie das Formular aus: -| Field | Value | +| Feld | Wert | | --- | --- | -| **Name (A-Z,0-9,_)** | Enter a unique uppercase tier name, such as `COLDTIER`. | -| **Endpoint** | Enter the target RustFS S3 endpoint. | -| **Access Key** | Enter the access key for the target deployment. | -| **Secret Key** | Enter the secret key for the target deployment. | -| **Bucket** | Enter the existing target bucket name, such as `my-bucket`. | -| **Prefix (Optional)** | Optionally enter a prefix dedicated to tiered objects. | -| **Region** | Optionally enter the target region, such as `us-east-1`. | +| **Name (A-Z,0-9,_)** | Geben Sie einen eindeutigen Stufennamen in Großbuchstaben ein, etwa `COLDTIER`. | +| **Endpoint** | Geben Sie den S3-Endpunkt der Ziel-RustFS ein. | +| **Access Key** | Geben Sie den Zugriffsschlüssel der Zielbereitstellung ein. | +| **Secret Key** | Geben Sie den geheimen Zugriffsschlüssel der Zielbereitstellung ein. | +| **Bucket** | Geben Sie den Namen des vorhandenen Ziel-Buckets ein, etwa `my-bucket`. | +| **Prefix (Optional)** | Geben Sie optional ein Präfix ein, das den gestuften Objekten vorbehalten ist. | +| **Region** | Geben Sie optional die Zielregion ein, etwa `us-east-1`. | -Leave **Storage Class** at its default unless the target backend requires a different supported storage class. +Belassen Sie **Storage Class** beim Standardwert, es sei denn, das Ziel-Backend erfordert eine andere unterstützte Speicherklasse. -:::warning[Protect tier credentials] +:::warning[Stufen-Zugangsdaten schützen] -The form contains a secret key. Use credentials restricted to the target bucket and prefix. Do not expose the key in screenshots, tickets, or logs. +Das Formular enthält einen geheimen Zugriffsschlüssel. Verwenden Sie Zugangsdaten, die auf den Ziel-Bucket und das Präfix beschränkt sind. Legen Sie den Schlüssel nicht in Screenshots, Tickets oder Protokollen offen. ::: -## 4. Save the tier +## 4. Stufe speichern -Select **Save**. RustFS validates the backend and probes it by writing, reading, and removing a small object. Saving fails when the endpoint, credentials, bucket permissions, or backend configuration cannot complete that probe. +Wählen Sie **Save** (Speichern). RustFS prüft das Backend, indem es ein kleines Objekt schreibt, liest und entfernt. Das Speichern schlägt fehl, wenn Endpunkt, Zugangsdaten, Bucket-Berechtigungen oder Backend-Konfiguration diese Prüfung nicht abschließen können. -After the tier appears in the **Tiers** list, configure a transition rule in [Lifecycle Management](/administration/data/lifecycle-management). A registered tier does not move objects until a lifecycle rule references its name. +Nachdem die Stufe in der Liste **Tiers** (Stufen) erscheint, konfigurieren Sie eine Übergangsregel unter [Lebenszyklusverwaltung](/de/administration/data/lifecycle-management). Eine registrierte Stufe verschiebt keine Objekte, bis eine Lebenszyklusregel ihren Namen referenziert. -## Manage tiers with `rc` +## Stufen mit `rc` verwalten -Install and configure [`rc`](/operations/rc), then list the tiers registered on the source deployment: +Installieren und konfigurieren Sie [`rc`](/de/operations/rc) und listen Sie anschließend die auf der Quellbereitstellung registrierten Stufen auf: ```bash rc bucket lifecycle tier list local ``` -Add a RustFS tier with the same settings described in the Console workflow: +Fügen Sie eine RustFS-Stufe mit denselben Einstellungen hinzu, die der Ablauf in der Console beschreibt: ```bash rc bucket lifecycle tier add rustfs COLDTIER local \ @@ -105,13 +105,13 @@ rc bucket lifecycle tier add rustfs COLDTIER local \ --region us-east-1 ``` -Inspect the tier configuration and available statistics: +Zeigen Sie die Stufenkonfiguration und die verfügbaren Statistiken an: ```bash rc bucket lifecycle tier info COLDTIER local ``` -The remaining tier commands update credentials or remove a tier: +Die übrigen Stufenbefehle aktualisieren Zugangsdaten oder entfernen eine Stufe: ```bash rc bucket lifecycle tier edit COLDTIER local \ @@ -120,60 +120,60 @@ rc bucket lifecycle tier edit COLDTIER local \ rc bucket lifecycle tier remove COLDTIER local ``` -See [Lifecycle Management](/administration/data/lifecycle-management) to create transition rules, confirm transitions, and restore local copies. Run `rc bucket lifecycle tier --help` to inspect provider-specific options before changing a tier. +Unter [Lebenszyklusverwaltung](/de/administration/data/lifecycle-management) erstellen Sie Übergangsregeln, bestätigen Übergänge und stellen lokale Kopien wieder her. Führen Sie `rc bucket lifecycle tier --help` aus, um anbieterspezifische Optionen anzuzeigen, bevor Sie eine Stufe ändern. -## Monitor tier activity +## Stufenaktivität überwachen -Use the tier statistics endpoint with a SigV4-signed request and `admin:ListTier` permission: +Verwenden Sie den Statistikendpunkt der Stufe mit einer SigV4-signierten Anfrage und der Berechtigung `admin:ListTier`: ```http GET /rustfs/admin/v3/tier-stats?tier=COLDTIER HTTP/1.1 Host: ``` -Monitor transition failures together with source-cluster capacity and target-side availability. A configured tier adds the target service and network path to the read path for objects that do not have a restored local copy. +Überwachen Sie Übergangsfehler zusammen mit der Kapazität des Quellclusters und der Verfügbarkeit auf der Zielseite. Eine konfigurierte Stufe fügt den Zieldienst und den Netzwerkpfad dem Lesepfad für Objekte hinzu, die keine wiederhergestellte lokale Kopie haben. -## Change or remove a tier +## Stufe ändern oder entfernen -The Admin API exposes these mutation routes, all requiring `admin:SetTier`: +Die Admin-API stellt diese ändernden Routen bereit. Alle erfordern `admin:SetTier`: | Operation | Route | | --- | --- | -| Edit a tier | `POST /rustfs/admin/v3/tier/{tiername}` | -| Remove a tier | `DELETE /rustfs/admin/v3/tier/{tiername}` | -| Clear all tiers | `POST /rustfs/admin/v3/tier/clear` | +| Stufe bearbeiten | `POST /rustfs/admin/v3/tier/{tiername}` | +| Stufe entfernen | `DELETE /rustfs/admin/v3/tier/{tiername}` | +| Alle Stufen löschen | `POST /rustfs/admin/v3/tier/clear` | -Before editing or removing a tier: +Bevor Sie eine Stufe bearbeiten oder entfernen: -1. Disable lifecycle rules that reference the tier. -2. Confirm that no transition jobs are still using it. -3. Confirm that no source objects depend on data stored in its target bucket or prefix. -4. Back up the tier configuration and record the target location. +1. Deaktivieren Sie Lebenszyklusregeln, die die Stufe referenzieren. +2. Prüfen Sie, dass keine Übergangsaufträge sie noch verwenden. +3. Prüfen Sie, dass keine Quellobjekte von Daten abhängen, die in ihrem Ziel-Bucket oder Präfix gespeichert sind. +4. Sichern Sie die Stufenkonfiguration und notieren Sie den Zielort. -Normal tier mutations check backend usage and protect non-empty targets. Do not use a `force` option to bypass those checks unless you have independently proved that every transitioned object remains recoverable. Removing configuration for an active tier can make transitioned objects unreadable from the source cluster. +Normale Stufenänderungen prüfen die Backend-Nutzung und schützen nicht leere Ziele. Verwenden Sie eine `force`-Option nicht, um diese Prüfungen zu umgehen, es sei denn, Sie haben unabhängig nachgewiesen, dass jedes übertragene Objekt wiederherstellbar bleibt. Wenn Sie die Konfiguration einer aktiven Stufe entfernen, können übertragene Objekte vom Quellcluster aus unlesbar werden. -:::warning[Do not modify tier objects directly] +:::warning[Stufenobjekte nicht direkt ändern] -Do not rename, overwrite, or delete generated objects in the target bucket. Manage source objects through the hot RustFS cluster so RustFS can keep local transition metadata and remote data consistent. +Benennen Sie erzeugte Objekte im Ziel-Bucket nicht um, überschreiben Sie sie nicht und löschen Sie sie nicht. Verwalten Sie Quellobjekte über den heißen RustFS-Cluster, damit RustFS lokale Übergangsmetadaten und entfernte Daten konsistent halten kann. ::: -## Admin API reference +## Referenz der Admin-API -The current RustFS source registers these tier routes: +Der aktuelle RustFS-Quellcode registriert diese Stufenrouten: -| Method | Route | Permission | +| Methode | Route | Berechtigung | | --- | --- | --- | | `PUT` | `/rustfs/admin/v3/tier` | `admin:SetTier` | | `POST` | `/rustfs/admin/v3/tier/{tiername}` | `admin:SetTier` | | `DELETE` | `/rustfs/admin/v3/tier/{tiername}` | `admin:SetTier` | | `POST` | `/rustfs/admin/v3/tier/clear` | `admin:SetTier` | -| `GET` | `/rustfs/admin/v3/tier` (list configurations) | `admin:ListTier` | -| `GET` | `/rustfs/admin/v3/tier/{tier}` (verify connectivity) | `admin:ListTier` | -| `GET` | `/rustfs/admin/v3/tier-stats` (read statistics) | `admin:ListTier` | +| `GET` | `/rustfs/admin/v3/tier` (Konfigurationen auflisten) | `admin:ListTier` | +| `GET` | `/rustfs/admin/v3/tier/{tier}` (Konnektivität prüfen) | `admin:ListTier` | +| `GET` | `/rustfs/admin/v3/tier-stats` (Statistiken lesen) | `admin:ListTier` | -All Admin API requests require SigV4 authentication. These routes are an administrative interface, not ordinary S3 bucket operations. +Alle Anfragen an die Admin-API erfordern SigV4-Authentifizierung. Diese Routen sind eine administrative Schnittstelle und keine gewöhnlichen S3-Bucket-Operationen. -## Next steps +## Nächste Schritte -Review [lifecycle management](/administration/data/lifecycle-management) and configure [access policies](/security-compliance/iam/policies) for the administrators and service credentials used by tiered storage. \ No newline at end of file +Lesen Sie die [Lebenszyklusverwaltung](/de/administration/data/lifecycle-management) und konfigurieren Sie [Zugriffsrichtlinien](/de/security-compliance/iam/policies) für die Administratoren und Dienst-Zugangsdaten der gestuften Speicherung. diff --git a/content/de/administration/index.md b/content/de/administration/index.md index 51cf0a7a2..a6290f832 100644 --- a/content/de/administration/index.md +++ b/content/de/administration/index.md @@ -1,17 +1,17 @@ --- title: "Administration" -description: "Administer RustFS data, access protocols, and browser-based management." +description: "Verwalten Sie RustFS-Daten, Zugriffsprotokolle und die browserbasierte Administration." --- -Use this section to manage RustFS through the Console, administer buckets and objects, and configure access protocols. +In diesem Abschnitt verwalten Sie RustFS über die Console (Weboberfläche), administrieren Buckets und Objekte und konfigurieren Zugriffsprotokolle. -## Administration areas +## Administrationsbereiche -- [Console](./console/index.md) covers browser-based administration and sign-in methods. -- [Data Management](./data/object/object-lock.md) covers buckets, objects, lifecycle behavior, and data protection features. -- [S3 Tables](/administration/data/s3-tables) behandelt Tabellen-Buckets und den integrierten Iceberg-REST-Katalog. -- [Protocol Support](./protocols/s3.md) covers S3, WebDAV, FTPS, and SFTP access. -- [CORS Configuration](./cors/index.md) covers cross-origin access to RustFS services. -- [Virtual-Host Access](/integration/virtual) covers domain-based S3 addressing. +- [Console](./console/index.md) beschreibt die browserbasierte Administration und die Anmeldeverfahren. +- [Datenverwaltung](./data/object/object-lock.md) beschreibt Buckets, Objekte, das Lebenszyklusverhalten und Funktionen zum Schutz von Daten. +- [S3 Tables](/de/administration/data/s3-tables) behandelt Tabellen-Buckets und den integrierten Iceberg-REST-Katalog. +- [Protokollunterstützung](./protocols/s3.md) beschreibt den Zugriff über S3, WebDAV, FTPS und SFTP. +- [CORS-Konfiguration](./cors/index.md) beschreibt den ursprungsübergreifenden Zugriff auf RustFS-Dienste. +- [Anfragen im Virtual-Hosted-Stil](/de/integration/virtual) beschreiben die domänenbasierte S3-Adressierung. -For identity, encryption, transport security, and auditing, continue with [Security & Compliance](/security-compliance). +Für Identität, Verschlüsselung, Transportsicherheit und Audit-Protokollierung lesen Sie [Sicherheit und Compliance](/de/security-compliance). diff --git a/content/de/administration/protocols/ftps.md b/content/de/administration/protocols/ftps.md index e7031a026..ac338b6aa 100644 --- a/content/de/administration/protocols/ftps.md +++ b/content/de/administration/protocols/ftps.md @@ -1,83 +1,83 @@ --- title: "FTP(S)" -description: "Configure the RustFS FTP or FTPS gateway and manage buckets and objects with FTP clients." +description: "Konfigurieren Sie das FTP- oder FTPS-Gateway von RustFS und verwalten Sie Buckets und Objekte mit FTP-Clients." --- -RustFS includes an FTP gateway that exposes buckets and objects to standard FTP clients. You can run it as unencrypted FTP for isolated local testing or as explicit FTP over TLS (FTPS) for encrypted connections. RustFS authenticates each session against Identity and Access Management (IAM) and applies the user's S3 policies to storage operations. +RustFS enthält ein FTP-Gateway, das Buckets und Objekte für Standard-FTP-Clients bereitstellt. Sie können es als unverschlüsseltes FTP für isolierte lokale Tests oder als explizites FTP über TLS (FTPS) für verschlüsselte Verbindungen betreiben. RustFS authentifiziert jede Sitzung gegen Identity and Access Management (IAM) und wendet die S3-Richtlinien des Benutzers auf Speicheroperationen an. -FTP and FTPS support is compiled into the standard RustFS binary, but both listeners are disabled at runtime by default. Enable only the listener you intend to use. +Die Unterstützung für FTP und FTPS ist im Standard-Binary von RustFS enthalten, beide Listener sind zur Laufzeit jedoch standardmäßig deaktiviert. Aktivieren Sie nur den Listener, den Sie verwenden möchten. -## Overview +## Überblick -The gateway maps FTP paths to RustFS resources: +Das Gateway bildet FTP-Pfade auf RustFS-Ressourcen ab: -| FTP path | RustFS resource | +| FTP-Pfad | RustFS-Ressource | | --- | --- | -| `/` | All buckets visible to the authenticated user | -| `/my-bucket/` | The `my-bucket` bucket | -| `/my-bucket/hello.txt` | The `hello.txt` object in `my-bucket` | +| `/` | Alle Buckets, die für den authentifizierten Benutzer sichtbar sind | +| `/my-bucket/` | Der Bucket `my-bucket` | +| `/my-bucket/hello.txt` | Das Objekt `hello.txt` in `my-bucket` | -The following FTP operations are supported: +Die folgenden FTP-Operationen werden unterstützt: -| FTP command | Operation | +| FTP-Befehl | Operation | | --- | --- | -| `LIST` | List buckets at the root or objects and prefixes in a bucket | -| `MKD` | Create a bucket | -| `CWD` | Enter a bucket | -| `STOR` | Upload an object | -| `RETR` | Download an object | -| `DELE` | Delete an object | -| `RMD` | Recursively delete a bucket and its objects | +| `LIST` | Buckets am Wurzelverzeichnis oder Objekte und Präfixe in einem Bucket auflisten | +| `MKD` | Bucket erstellen | +| `CWD` | Bucket betreten | +| `STOR` | Objekt hochladen | +| `RETR` | Objekt herunterladen | +| `DELE` | Objekt löschen | +| `RMD` | Bucket und seine Objekte rekursiv löschen | -RustFS does not currently support FTP rename operations or uploads that append to an existing object. Because S3 storage has no native working-directory or POSIX directory model, some client-specific filesystem operations may not behave like a traditional FTP server. +RustFS unterstützt derzeit keine FTP-Umbenennungen und keine Uploads, die an ein vorhandenes Objekt angefügt werden. Weil der S3-Speicher kein natives Arbeitsverzeichnis und kein POSIX-Verzeichnismodell hat, verhalten sich manche clientspezifischen Dateisystemoperationen anders als bei einem herkömmlichen FTP-Server. -Enter a RustFS access key as the FTP username and its secret key as the password. Invalid usernames and passwords both return `530 Not logged in`. After login, RustFS checks the IAM user's S3 permissions for each operation. +Geben Sie einen RustFS-Zugriffsschlüssel als FTP-Benutzernamen und den zugehörigen geheimen Zugriffsschlüssel als Passwort ein. Ungültige Benutzernamen und Passwörter geben beide `530 Not logged in` zurück. Nach der Anmeldung prüft RustFS die S3-Berechtigungen des IAM-Benutzers für jede Operation. -:::danger[Plain FTP exposes credentials] +:::danger[Unverschlüsseltes FTP legt Zugangsdaten offen] -FTP sends credentials and data without encryption. Bind plain FTP to a loopback or isolated test network only. Use FTPS for every remote or production connection. +FTP sendet Zugangsdaten und Daten ohne Verschlüsselung. Binden Sie unverschlüsseltes FTP nur an ein Loopback oder ein isoliertes Testnetz. Verwenden Sie FTPS für jede entfernte oder produktive Verbindung. ::: -:::warning[Bucket deletion is recursive] +:::warning[Das Löschen eines Buckets ist rekursiv] -The current `RMD` implementation deletes the objects in the target bucket before deleting the bucket. Confirm the path before running `rmdir` in an FTP client. +Die aktuelle Implementierung von `RMD` löscht die Objekte im Ziel-Bucket, bevor sie den Bucket löscht. Prüfen Sie den Pfad, bevor Sie `rmdir` in einem FTP-Client ausführen. ::: -## Configuration +## Konfiguration -FTP and FTPS use separate listeners and environment variables. +FTP und FTPS verwenden getrennte Listener und Umgebungsvariablen. -### FTP variables +### FTP-Variablen -| Variable | Description | Default | +| Variable | Beschreibung | Standard | | --- | --- | --- | -| `RUSTFS_FTP_ENABLE` | Enables the unencrypted FTP listener. | `false` | -| `RUSTFS_FTP_ADDRESS` | Bind address for FTP control connections. | `0.0.0.0:8021` | -| `RUSTFS_FTP_PASSIVE_PORTS` | Inclusive passive data port range in `start-end` format. | `40000-50000` | -| `RUSTFS_FTP_EXTERNAL_IP` | Public IP or hostname advertised to passive clients when RustFS is behind NAT. | Not set | +| `RUSTFS_FTP_ENABLE` | Aktiviert den unverschlüsselten FTP-Listener. | `false` | +| `RUSTFS_FTP_ADDRESS` | Bind-Adresse für FTP-Steuerverbindungen. | `0.0.0.0:8021` | +| `RUSTFS_FTP_PASSIVE_PORTS` | Bereich passiver Datenports im Format `start-end`, einschließlich Anfang und Ende. | `40000-50000` | +| `RUSTFS_FTP_EXTERNAL_IP` | Öffentliche IP oder öffentlicher Hostname, der passiven Clients mitgeteilt wird, wenn RustFS hinter NAT steht. | Nicht gesetzt | -### FTPS variables +### FTPS-Variablen -| Variable | Description | Default | +| Variable | Beschreibung | Standard | | --- | --- | --- | -| `RUSTFS_FTPS_ENABLE` | Enables the explicit FTPS listener. | `false` | -| `RUSTFS_FTPS_ADDRESS` | Bind address for FTPS control connections. | `0.0.0.0:8022` | -| `RUSTFS_FTPS_TLS_ENABLED` | Enables TLS on the FTPS listener. Keep this enabled for FTPS. | `true` | -| `RUSTFS_FTPS_CERTS_DIR` | Directory containing the FTPS certificate and private key. Required for FTPS. | Not set | -| `RUSTFS_FTPS_PASSIVE_PORTS` | Inclusive passive data port range in `start-end` format. | `40000-50000` | -| `RUSTFS_FTPS_EXTERNAL_IP` | Public IP or hostname advertised to passive clients when RustFS is behind NAT. | Not set | +| `RUSTFS_FTPS_ENABLE` | Aktiviert den Listener für explizites FTPS. | `false` | +| `RUSTFS_FTPS_ADDRESS` | Bind-Adresse für FTPS-Steuerverbindungen. | `0.0.0.0:8022` | +| `RUSTFS_FTPS_TLS_ENABLED` | Aktiviert TLS auf dem FTPS-Listener. Lassen Sie dies für FTPS aktiviert. | `true` | +| `RUSTFS_FTPS_CERTS_DIR` | Verzeichnis mit dem FTPS-Zertifikat und dem privaten Schlüssel. Für FTPS erforderlich. | Nicht gesetzt | +| `RUSTFS_FTPS_PASSIVE_PORTS` | Bereich passiver Datenports im Format `start-end`, einschließlich Anfang und Ende. | `40000-50000` | +| `RUSTFS_FTPS_EXTERNAL_IP` | Öffentliche IP oder öffentlicher Hostname, der passiven Clients mitgeteilt wird, wenn RustFS hinter NAT steht. | Nicht gesetzt | -The standard RustFS build enables the `ftps` compile-time feature, which provides both FTP and FTPS. If you build RustFS with `--no-default-features`, include the feature explicitly: +Der Standard-Build von RustFS aktiviert das Feature `ftps` zur Build-Zeit, das sowohl FTP als auch FTPS bereitstellt. Wenn Sie RustFS mit `--no-default-features` bauen, nehmen Sie das Feature ausdrücklich auf: ```bash cargo build --release --features ftps ``` -### Local testing with FTP +### Lokale Tests mit FTP -Start an unencrypted FTP listener on the loopback interface: +Starten Sie einen unverschlüsselten FTP-Listener auf der Loopback-Schnittstelle: ```bash export RUSTFS_FTP_ENABLE=true @@ -89,11 +89,11 @@ export RUSTFS_SECRET_KEY= rustfs /path/to/data ``` -Binding to `127.0.0.1` prevents remote hosts from connecting to the unencrypted listener. +Die Bindung an `127.0.0.1` verhindert, dass entfernte Hosts eine Verbindung zum unverschlüsselten Listener aufbauen. -### Prepare a test certificate +### Testzertifikat vorbereiten -FTPS expects `rustfs_cert.pem` and `rustfs_key.pem` in the certificate directory. For local testing, create a short-lived self-signed certificate: +FTPS erwartet `rustfs_cert.pem` und `rustfs_key.pem` im Zertifikatsverzeichnis. Erstellen Sie für lokale Tests ein kurzlebiges selbstsigniertes Zertifikat: ```bash mkdir -p /path/to/ftps-certs @@ -106,11 +106,11 @@ openssl req -x509 -newkey rsa:2048 -nodes \ -addext "subjectAltName=DNS:localhost,IP:127.0.0.1" ``` -Use a certificate issued by a trusted certificate authority in production. Protect `rustfs_key.pem` from unauthorized access and ensure the certificate subject alternative names match the host clients use. +Verwenden Sie in der Produktion ein Zertifikat einer vertrauenswürdigen Zertifizierungsstelle. Schützen Sie `rustfs_key.pem` vor unberechtigtem Zugriff und stellen Sie sicher, dass die Subject Alternative Names des Zertifikats zum Host passen, den Clients verwenden. -### Start FTPS +### FTPS starten -Configure an explicit FTPS listener: +Konfigurieren Sie einen Listener für explizites FTPS: ```bash export RUSTFS_FTPS_ENABLE=true @@ -122,44 +122,44 @@ export RUSTFS_FTPS_PASSIVE_PORTS=40000-50000 rustfs /path/to/data ``` -RustFS requires TLS on both the FTPS control and data channels. Configure clients for **explicit FTP over TLS**, sometimes labeled **FTPES** or **Require explicit FTP over TLS**. Implicit FTPS is not the mode implemented by this listener. +RustFS verlangt TLS sowohl auf dem FTPS-Steuerkanal als auch auf dem Datenkanal. Konfigurieren Sie Clients für **explicit FTP over TLS** (explizites FTP über TLS), manchmal bezeichnet als **FTPES** oder **Require explicit FTP over TLS**. Implizites FTPS ist nicht der Modus, den dieser Listener implementiert. -If the certificate directory is missing, does not exist, or does not contain a usable certificate and key, FTPS initialization fails. See [Configure TLS](/integration/tls-configured) for general certificate guidance. +Wenn das Zertifikatsverzeichnis fehlt, nicht vorhanden ist oder kein verwendbares Zertifikat und keinen verwendbaren Schlüssel enthält, schlägt die FTPS-Initialisierung fehl. Allgemeine Hinweise zu Zertifikaten stehen unter [TLS konfigurieren](/de/integration/tls-configured). -### Configure passive connections +### Passive Verbindungen konfigurieren -FTP uses the control port for commands and a separate data connection for listings and file transfers. For passive mode: +FTP verwendet den Steuerport für Befehle und eine separate Datenverbindung für Auflistungen und Dateiübertragungen. Für den passiven Modus: -1. Allow inbound TCP traffic to the configured control port. -2. Allow inbound TCP traffic to every port in the configured passive range. -3. Set `RUSTFS_FTP_EXTERNAL_IP` or `RUSTFS_FTPS_EXTERNAL_IP` when clients connect through NAT or a load balancer. +1. Lassen Sie eingehenden TCP-Verkehr zum konfigurierten Steuerport zu. +2. Lassen Sie eingehenden TCP-Verkehr zu jedem Port im konfigurierten passiven Bereich zu. +3. Setzen Sie `RUSTFS_FTP_EXTERNAL_IP` oder `RUSTFS_FTPS_EXTERNAL_IP`, wenn Clients über NAT oder einen Load Balancer verbinden. -For example, an FTPS server behind NAT can advertise its public hostname: +Ein FTPS-Server hinter NAT kann beispielsweise seinen öffentlichen Hostnamen bekannt geben: ```bash export RUSTFS_FTPS_EXTERNAL_IP=storage.example.com export RUSTFS_FTPS_PASSIVE_PORTS=40000-40100 ``` -Use the corresponding FTP-prefixed variables for the plain FTP listener. RustFS supports both active and passive transfer modes, but passive mode is generally easier to operate through client firewalls. +Verwenden Sie die entsprechenden Variablen mit FTP-Präfix für den unverschlüsselten FTP-Listener. RustFS unterstützt den aktiven und den passiven Übertragungsmodus. Der passive Modus lässt sich durch Client-Firewalls in der Regel leichter betreiben. -## Usage +## Verwendung -The examples use [`lftp`](https://lftp.yar.ru/) and the canonical `my-bucket` and `hello.txt` names. The IAM user must have the S3 permissions required for each operation. +Die Beispiele verwenden [`lftp`](https://lftp.yar.ru/) sowie die kanonischen Namen `my-bucket` und `hello.txt`. Der IAM-Benutzer muss die S3-Berechtigungen besitzen, die jede Operation erfordert. -### Connect with FTP +### Mit FTP verbinden -Use plain FTP only with the loopback test listener: +Verwenden Sie unverschlüsseltes FTP nur mit dem Loopback-Testlistener: ```bash lftp -u ftp://127.0.0.1:8021 ``` -Enter the secret key when `lftp` prompts for a password. +Geben Sie den geheimen Zugriffsschlüssel ein, wenn `lftp` nach einem Passwort fragt. -### Connect with FTPS +### Mit FTPS verbinden -Connect to the explicit FTPS listener and require encryption for control and data connections: +Verbinden Sie sich mit dem Listener für explizites FTPS und verlangen Sie Verschlüsselung für Steuer- und Datenverbindungen: ```bash lftp -u -e ' @@ -169,9 +169,9 @@ lftp -u -e ' ' ``` -Enter the secret key when prompted. Keep certificate verification enabled in production. +Geben Sie den geheimen Zugriffsschlüssel ein, wenn Sie dazu aufgefordert werden. Lassen Sie die Zertifikatsprüfung in der Produktion aktiviert. -For the self-signed local test certificate only, connect to `localhost` and disable certificate verification for that session: +Nur für das selbstsignierte lokale Testzertifikat verbinden Sie sich mit `localhost` und deaktivieren Sie die Zertifikatsprüfung für diese Sitzung: ```bash lftp -u -e ' @@ -184,13 +184,13 @@ lftp -u -e ' :::warning -Do not disable certificate verification in production. Install the issuing CA in the client trust store instead. +Deaktivieren Sie die Zertifikatsprüfung nicht in der Produktion. Installieren Sie stattdessen die ausstellende Zertifizierungsstelle im Vertrauensspeicher des Clients. ::: -### List buckets and create a bucket +### Buckets auflisten und einen Bucket erstellen -At the `lftp` prompt, list the visible buckets and create `my-bucket`: +Listen Sie an der `lftp`-Eingabeaufforderung die sichtbaren Buckets auf und erstellen Sie `my-bucket`: ```text lftp> cls -1 / @@ -198,11 +198,11 @@ lftp> mkdir my-bucket lftp> cd my-bucket ``` -Bucket names must follow the same naming rules as buckets created through the S3 API. +Bucket-Namen müssen denselben Namensregeln folgen wie Buckets, die über die S3-API erstellt werden. -### Upload and download an object +### Objekt hochladen und herunterladen -Upload `/path/to/hello.txt`, list the bucket, and download the object: +Laden Sie `/path/to/hello.txt` hoch, listen Sie den Bucket auf und laden Sie das Objekt herunter: ```text lftp> put /path/to/hello.txt -o hello.txt @@ -210,11 +210,11 @@ lftp> ls lftp> get hello.txt -o hello.txt ``` -The upload replaces an object with the same key. Appending to an existing object is not supported. +Der Upload ersetzt ein Objekt mit demselben Objektschlüssel. Das Anfügen an ein vorhandenes Objekt wird nicht unterstützt. -### Delete an object and bucket +### Objekt und Bucket löschen -Delete the object, return to the root, and delete the bucket: +Löschen Sie das Objekt, kehren Sie zum Wurzelverzeichnis zurück und löschen Sie den Bucket: ```text lftp> rm hello.txt @@ -222,25 +222,25 @@ lftp> cd / lftp> rmdir my-bucket ``` -Remember that `rmdir` recursively removes remaining objects from the bucket before deleting it. +Denken Sie daran, dass `rmdir` verbleibende Objekte rekursiv aus dem Bucket entfernt, bevor es ihn löscht. -### Connect other clients +### Andere Clients verbinden -Use these settings in graphical FTP clients such as FileZilla or Cyberduck: +Verwenden Sie diese Einstellungen in grafischen FTP-Clients wie FileZilla oder Cyberduck: -| Setting | FTP test listener | FTPS listener | +| Einstellung | FTP-Testlistener | FTPS-Listener | | --- | --- | --- | -| Protocol | FTP | FTP over TLS (explicit) | -| Host | `127.0.0.1` | Your FTPS hostname | +| Protokoll | FTP | FTP over TLS (explicit) | +| Host | `127.0.0.1` | Ihr FTPS-Hostname | | Port | `8021` | `8022` | -| Username | RustFS access key | RustFS access key | -| Password | RustFS secret key | RustFS secret key | -| Transfer mode | Passive | Passive | +| Benutzername | RustFS-Zugriffsschlüssel | RustFS-Zugriffsschlüssel | +| Passwort | Geheimer Zugriffsschlüssel von RustFS | Geheimer Zugriffsschlüssel von RustFS | +| Übertragungsmodus | Passiv | Passiv | -If login succeeds but directory listings or transfers time out, check the passive port firewall rules and external IP setting first. +Wenn die Anmeldung gelingt, Verzeichnisauflistungen oder Übertragungen aber in ein Zeitlimit laufen, prüfen Sie zuerst die Firewall-Regeln der passiven Ports und die Einstellung der externen IP. -## Next steps +## Nächste Schritte -- [Manage credentials](/operations/credentials) -- [Configure TLS](/integration/tls-configured) -- [Check service status](/operations/status-check) \ No newline at end of file +- [Zugangsdaten verwalten](/de/operations/credentials) +- [TLS konfigurieren](/de/integration/tls-configured) +- [Dienststatus prüfen](/de/operations/status-check) diff --git a/content/de/administration/protocols/s3.md b/content/de/administration/protocols/s3.md index 0148cd28b..4766bc788 100644 --- a/content/de/administration/protocols/s3.md +++ b/content/de/administration/protocols/s3.md @@ -1,111 +1,111 @@ --- title: "S3" -description: "Configure and use the RustFS S3-compatible API with AWS CLI, AWS SDKs, and other S3 clients." +description: "Konfigurieren und verwenden Sie die S3-kompatible API von RustFS mit der AWS CLI, AWS-SDKs und anderen S3-Clients." --- -RustFS exposes an S3-compatible REST API for common object-storage workloads. It supports AWS Signature Version 4 (SigV4) and works with AWS CLI, AWS SDKs, and other S3 clients when you configure the RustFS endpoint, region, credentials, and addressing style. +RustFS stellt eine S3-kompatible REST-API für gängige Objektspeicher-Workloads bereit. Sie unterstützt AWS Signature Version 4 (SigV4) und arbeitet mit der AWS CLI, AWS-SDKs und anderen S3-Clients, wenn Sie den RustFS-Endpunkt, die Region, die Zugangsdaten und den Adressierungsstil konfigurieren. -## Overview +## Überblick -S3 organizes data into buckets and objects. With the default path-style addressing, a RustFS URL maps to storage as follows: +S3 organisiert Daten in Buckets und Objekten. Mit der standardmäßigen pfadbasierten Adressierung (Path-Style) bildet eine RustFS-URL den Speicher so ab: ```text http://localhost:9000/my-bucket/path/to/hello.txt | bucket | |---- object key ----| ``` -RustFS covers the common S3 data plane used by applications, backup tools, and SDKs: +RustFS deckt die gängige S3-Datenebene ab, die Anwendungen, Sicherungswerkzeuge und SDKs verwenden: -| Area | Supported workflows | +| Bereich | Unterstützte Abläufe | | --- | --- | -| Buckets | Create, delete, list, inspect, and retrieve location | -| Objects | Put, get, head, copy, delete, multi-delete, range reads, conditional requests, and user metadata | -| Listing | `ListObjects`, `ListObjectsV2`, prefixes, delimiters, markers, and pagination | -| Large objects | Create, upload, copy, list, complete, and abort multipart uploads | -| Data management | Versioning, lifecycle rules, bucket and object tags, checksums, and object lock | -| Access control | IAM credentials and policies, bucket policies, public access block, and presigned GET/PUT URLs | -| Integration | CORS, bucket notifications, replication configuration, and server-side encryption workflows | +| Buckets | Erstellen, löschen, auflisten, Metadaten abrufen (Head) und den Standort abrufen | +| Objekte | Schreiben, lesen, Metadaten abrufen, kopieren, löschen, mehrfach löschen, Bereichslesevorgänge, bedingte Anfragen und Benutzermetadaten | +| Auflisten | `ListObjects`, `ListObjectsV2`, Präfixe, Trennzeichen, Marker und Seitenaufteilung | +| Große Objekte | Mehrteilige Uploads erstellen, hochladen, kopieren, auflisten, abschließen und abbrechen | +| Datenverwaltung | Versionierung, Lebenszyklusregeln, Bucket- und Objekt-Tags, Prüfsummen und Object Lock | +| Zugriffskontrolle | IAM-Zugangsdaten und -Richtlinien, Bucket-Richtlinien, Public Access Block (Sperre für öffentlichen Zugriff) und vorsignierte GET- und PUT-URLs | +| Integration | CORS, Bucket-Benachrichtigungen, Replikationskonfiguration und Abläufe der serverseitigen Verschlüsselung | -Authenticated clients sign requests with an access key and secret key. Anonymous requests are evaluated against the applicable bucket policy. +Authentifizierte Clients signieren Anfragen mit einem Zugriffsschlüssel und einem geheimen Zugriffsschlüssel. Anonyme Anfragen werden gegen die zutreffende Bucket-Richtlinie geprüft. -:::note[Compatibility scope] +:::note[Kompatibilitätsumfang] -RustFS provides broad S3 API compatibility for supported features, but it is not identical to every AWS S3 or MinIO API. Review [Known compatibility differences](#known-compatibility-differences) before depending on advanced or vendor-specific behavior, and validate it against your target RustFS release. +RustFS bietet für unterstützte Funktionen eine breite Kompatibilität mit der S3-API, ist aber nicht mit jeder AWS-S3- oder MinIO-API identisch. Lesen Sie [Bekannte Kompatibilitätsunterschiede](#bekannte-kompatibilitätsunterschiede), bevor Sie sich auf erweitertes oder herstellerspezifisches Verhalten verlassen, und prüfen Sie es gegen Ihre Zielversion von RustFS. ::: -## Configuration +## Konfiguration -The S3 API is enabled on the main RustFS listener. It does not require a separate protocol switch. +Die S3-API ist auf dem Haupt-Listener von RustFS aktiviert. Sie benötigt keinen separaten Protokollschalter. -| Variable | Purpose | Default | +| Variable | Zweck | Standard | | --- | --- | --- | -| `RUSTFS_ADDRESS` | S3 API bind address | `:9000` | -| `RUSTFS_REGION` | Region used for request signing and region-aware clients | `us-east-1` | -| `RUSTFS_ACCESS_KEY` | Root access key | Installation-specific | -| `RUSTFS_SECRET_KEY` | Root secret key | Installation-specific | -| `RUSTFS_SERVER_DOMAINS` | Comma-separated domains for virtual-hosted-style requests | Not set | -| `RUSTFS_TLS_PATH` | Directory containing `rustfs_cert.pem` and `rustfs_key.pem` | Not set | +| `RUSTFS_ADDRESS` | Bind-Adresse der S3-API | `:9000` | +| `RUSTFS_REGION` | Region für die Anfragesignatur und Clients, die die Region berücksichtigen | `us-east-1` | +| `RUSTFS_ACCESS_KEY` | Root-Zugriffsschlüssel | Installationsabhängig | +| `RUSTFS_SECRET_KEY` | Geheimer Root-Zugriffsschlüssel | Installationsabhängig | +| `RUSTFS_SERVER_DOMAINS` | Durch Kommas getrennte Domains für Anfragen mit Adressierung im Virtual-Hosted-Stil | Nicht gesetzt | +| `RUSTFS_TLS_PATH` | Verzeichnis mit `rustfs_cert.pem` und `rustfs_key.pem` | Nicht gesetzt | -Use IAM users or service accounts instead of root credentials for applications, and grant only the required S3 actions. +Verwenden Sie für Anwendungen IAM-Benutzer oder Dienstkonten anstelle der Root-Anmeldedaten und gewähren Sie nur die erforderlichen S3-Aktionen. -### Path-style addressing +### Pfadbasierte Adressierung -Path-style addressing is the default and requires no DNS configuration. The bucket name is the first component of the request path: +Die pfadbasierte Adressierung ist der Standard und erfordert keine DNS-Konfiguration. Der Bucket-Name ist die erste Komponente des Anfragepfads: ```text http://localhost:9000/my-bucket/hello.txt ``` -Configure clients with: +Konfigurieren Sie Clients mit: -- Endpoint: `http://localhost:9000` +- Endpunkt: `http://localhost:9000` - Region: `us-east-1` -- Access key: `` -- Secret key: `` -- Addressing style: path-style +- Zugriffsschlüssel: `` +- Geheimer Zugriffsschlüssel: `` +- Adressierungsstil: pfadbasierte Adressierung -Some clients default to virtual-hosted-style requests. Enable their path-style option, such as `force_path_style=true` in AWS SDK configuration or `s3_use_path_style = true` in Terraform. +Einige Clients verwenden standardmäßig die Adressierung im Virtual-Hosted-Stil. Aktivieren Sie ihre Option für pfadbasierte Adressierung, etwa `force_path_style=true` in der AWS-SDK-Konfiguration oder `s3_use_path_style = true` in Terraform. -### Virtual-hosted-style addressing +### Adressierung im Virtual-Hosted-Stil -Virtual-hosted-style addressing places the bucket name in the hostname. Set `RUSTFS_SERVER_DOMAINS` to each base domain that RustFS should recognize: +Die Adressierung im Virtual-Hosted-Stil setzt den Bucket-Namen in den Hostnamen. Setzen Sie `RUSTFS_SERVER_DOMAINS` auf jede Basisdomain, die RustFS erkennen soll: ```bash export RUSTFS_SERVER_DOMAINS="s3.example.com" ``` -The same object is then addressed as: +Dasselbe Objekt wird dann so adressiert: ```text https://my-bucket.s3.example.com/hello.txt ``` -Configure wildcard DNS, such as `*.s3.example.com`, to resolve to the RustFS endpoint. For HTTPS, the certificate must also cover the bucket hostnames. Bucket names containing dots may require explicit certificate names because a single-label wildcard does not span multiple labels. +Konfigurieren Sie Wildcard-DNS, etwa `*.s3.example.com`, sodass es auf den RustFS-Endpunkt aufgelöst wird. Für HTTPS muss das Zertifikat auch die Bucket-Hostnamen abdecken. Bucket-Namen mit Punkten können ausdrückliche Zertifikatsnamen erfordern, weil ein Wildcard mit einem Label nicht mehrere Labels umfasst. -:::warning[Configure the server domain] +:::warning[Serverdomain konfigurieren] -Do not send virtual-hosted-style requests unless `RUSTFS_SERVER_DOMAINS` is configured. RustFS otherwise treats requests as path-style and cannot derive the bucket from the hostname. +Senden Sie keine Anfragen mit Adressierung im Virtual-Hosted-Stil, solange `RUSTFS_SERVER_DOMAINS` nicht konfiguriert ist. Andernfalls behandelt RustFS die Anfragen als pfadbasierte Adressierung und kann den Bucket nicht aus dem Hostnamen ableiten. ::: -### TLS and network access +### TLS und Netzwerkzugriff -For production, set `RUSTFS_TLS_PATH` to a directory containing `rustfs_cert.pem` and `rustfs_key.pem`, then use an `https://` endpoint. Ensure clients trust the issuing certificate authority. +Setzen Sie in der Produktion `RUSTFS_TLS_PATH` auf ein Verzeichnis mit `rustfs_cert.pem` und `rustfs_key.pem` und verwenden Sie anschließend einen Endpunkt mit `https://`. Stellen Sie sicher, dass Clients der ausstellenden Zertifizierungsstelle vertrauen. -Allow the configured S3 API port through host firewalls and load balancers. The default is TCP port `9000`; this listener also carries RustFS administrative and internode traffic, so do not expose it anonymously without appropriate network and IAM controls. +Lassen Sie den konfigurierten S3-API-Port durch Host-Firewalls und Load Balancer zu. Der Standard ist TCP-Port `9000`. Dieser Listener überträgt auch administrativen Verkehr und Verkehr zwischen den Knoten von RustFS. Machen Sie ihn deshalb nicht anonym erreichbar, ohne passende Netzwerk- und IAM-Kontrollen. -## Usage +## Verwendung -The following examples use AWS CLI with the canonical local endpoint. Install and configure [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) before continuing. +Die folgenden Beispiele verwenden die AWS CLI mit dem kanonischen lokalen Endpunkt. Installieren und konfigurieren Sie die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html), bevor Sie fortfahren. -### Configure AWS CLI +### AWS CLI konfigurieren ```bash aws configure ``` -Enter these values when prompted: +Geben Sie diese Werte ein, wenn Sie dazu aufgefordert werden: ```text AWS Access Key ID [None]: @@ -114,13 +114,13 @@ Default region name [None]: us-east-1 Default output format [None]: json ``` -Pass the RustFS endpoint to every command. The custom endpoint keeps these examples on RustFS instead of AWS S3. +Übergeben Sie den RustFS-Endpunkt an jeden Befehl. Der benutzerdefinierte Endpunkt richtet diese Beispiele auf RustFS aus. ```bash export RUSTFS_ENDPOINT="http://localhost:9000" ``` -### Create and list buckets +### Buckets erstellen und auflisten ```bash aws --endpoint-url "$RUSTFS_ENDPOINT" s3api create-bucket \ @@ -129,7 +129,7 @@ aws --endpoint-url "$RUSTFS_ENDPOINT" s3api create-bucket \ aws --endpoint-url "$RUSTFS_ENDPOINT" s3api list-buckets ``` -### Upload and list objects +### Objekte hochladen und auflisten ```bash printf 'Hello from RustFS\n' > hello.txt @@ -141,9 +141,9 @@ aws --endpoint-url "$RUSTFS_ENDPOINT" s3 ls \ s3://my-bucket/path/to/ ``` -AWS CLI automatically uses multipart upload when its transfer configuration selects it for a large object. RustFS supports the standard multipart create, upload-part, complete, list, and abort workflows. +Die AWS CLI verwendet automatisch einen mehrteiligen Upload, wenn ihre Übertragungskonfiguration ihn für ein großes Objekt auswählt. RustFS unterstützt die Standardabläufe zum Erstellen, Hochladen von Teilen, Abschließen, Auflisten und Abbrechen mehrteiliger Uploads. -### Download and inspect an object +### Objekt herunterladen und Metadaten abrufen ```bash aws --endpoint-url "$RUSTFS_ENDPOINT" s3 cp \ @@ -154,9 +154,9 @@ aws --endpoint-url "$RUSTFS_ENDPOINT" s3api head-object \ --key path/to/hello.txt ``` -### Create a presigned URL +### Vorsignierte URL erstellen -Generate a time-limited URL that can download an object without exposing credentials: +Erzeugen Sie eine zeitlich begrenzte URL, mit der ein Objekt heruntergeladen werden kann, ohne Zugangsdaten offenzulegen: ```bash aws --endpoint-url "$RUSTFS_ENDPOINT" s3 presign \ @@ -164,9 +164,9 @@ aws --endpoint-url "$RUSTFS_ENDPOINT" s3 presign \ --expires-in 3600 ``` -The hostname, scheme, port, region, and object path used by the recipient must match the values used to sign the URL. Use the externally reachable endpoint when generating URLs for another machine. +Hostname, Schema, Port, Region und Objektpfad, die der Empfänger verwendet, müssen mit den Werten übereinstimmen, mit denen die URL signiert wurde. Verwenden Sie den von außen erreichbaren Endpunkt, wenn Sie URLs für einen anderen Rechner erzeugen. -### Delete objects and buckets +### Objekte und Buckets löschen ```bash aws --endpoint-url "$RUSTFS_ENDPOINT" s3 rm \ @@ -176,25 +176,25 @@ aws --endpoint-url "$RUSTFS_ENDPOINT" s3api delete-bucket \ --bucket my-bucket ``` -An S3 bucket must be empty before it can be deleted. +Ein S3-Bucket muss leer sein, bevor er gelöscht werden kann. -## Known compatibility differences +## Bekannte Kompatibilitätsunterschiede -Current RustFS compatibility tests cover the common workflows described above. The following areas are not equivalent to AWS S3 or MinIO: +Die aktuellen Kompatibilitätstests von RustFS decken die oben beschriebenen gängigen Abläufe ab. Die folgenden Bereiche sind nicht gleichwertig mit AWS S3 oder MinIO: -- Bucket access logging and bucket ownership controls are planned rather than complete. -- ACL authorization is intentionally unsupported. Canned ACL headers have partial compatibility, while XML grant policies return `NotImplemented`. Prefer IAM and bucket policies. -- POST Object form uploads are implemented, but checksum handling for that workflow is not complete. -- Some multipart upload listing and part-lookup edge cases are outside the default compatibility gate. -- S3 Select currently accepts only uncompressed input. -- Access Point and Outposts copy-source forms are not implemented. -- MinIO administrative APIs are a separate compatibility surface and should not be inferred from S3 data-plane support. +- Zugriffsprotokollierung für Buckets und Steuerungen der Bucket-Eigentümerschaft sind geplant und noch nicht abgeschlossen. +- Die ACL-Autorisierung wird absichtlich nicht unterstützt. Vordefinierte ACL-Header (Canned ACLs) sind teilweise kompatibel, während XML-Grant-Richtlinien `NotImplemented` zurückgeben. Bevorzugen Sie IAM- und Bucket-Richtlinien. +- Formular-Uploads mit POST Object sind implementiert, die Prüfsummenbehandlung für diesen Ablauf ist jedoch nicht abgeschlossen. +- Einige Randfälle beim Auflisten mehrteiliger Uploads und beim Nachschlagen von Teilen liegen außerhalb der standardmäßigen Kompatibilitätsprüfung (Compatibility Gate). +- S3 Select akzeptiert derzeit nur unkomprimierte Eingaben. +- Copy-Source-Formen von Access Point und Outposts sind nicht implementiert. +- Administrative MinIO-APIs sind eine eigene Kompatibilitätsfläche und lassen sich nicht aus der Unterstützung der S3-Datenebene ableiten. -Client behavior can also differ when a tool assumes AWS-specific services, storage classes, account ownership controls, or endpoint discovery. Always set the RustFS endpoint explicitly and test the exact operations your application uses. +Das Client-Verhalten kann zusätzlich abweichen, wenn ein Werkzeug AWS-spezifische Dienste, Speicherklassen, Steuerungen der Kontoeigentümerschaft oder eine Endpunkt-Erkennung voraussetzt. Setzen Sie den RustFS-Endpunkt immer ausdrücklich und testen Sie genau die Operationen, die Ihre Anwendung verwendet. -## Next steps +## Nächste Schritte -- Follow the complete [AWS CLI example](/developer/examples/aws-cli). -- Choose an [S3 SDK](/developer/sdk) for application integration. -- Configure [credentials and access policies](/operations/credentials). -- Enable [TLS](/integration/tls-configured) before exposing the endpoint outside a trusted network. +- Folgen Sie dem vollständigen [Beispiel zur AWS CLI](/de/developer/examples/aws-cli). +- Wählen Sie ein [S3-SDK](/de/developer/sdk) für die Anwendungsintegration. +- Konfigurieren Sie [Zugangsdaten und Zugriffsrichtlinien](/de/operations/credentials). +- Aktivieren Sie [TLS](/de/integration/tls-configured), bevor Sie den Endpunkt außerhalb eines vertrauenswürdigen Netzwerks erreichbar machen. diff --git a/content/de/administration/protocols/sftp.md b/content/de/administration/protocols/sftp.md index 3579364fd..f583248ef 100644 --- a/content/de/administration/protocols/sftp.md +++ b/content/de/administration/protocols/sftp.md @@ -1,74 +1,74 @@ --- title: "SFTP" -description: "Build, configure, and use the RustFS SFTP gateway to access buckets and objects with SFTP clients." +description: "Bauen, konfigurieren und verwenden Sie das SFTP-Gateway von RustFS, um mit SFTP-Clients auf Buckets und Objekte zuzugreifen." --- -RustFS includes an SSH File Transfer Protocol (SFTP) gateway that exposes buckets and objects to SFTP clients over an encrypted SSH connection. You can list and create buckets and upload, download, rename, or delete objects while RustFS enforces the permissions of the authenticated Identity and Access Management (IAM) user. +RustFS enthält ein Gateway für das SSH File Transfer Protocol (SFTP), das Buckets und Objekte über eine verschlüsselte SSH-Verbindung für SFTP-Clients bereitstellt. Sie können Buckets auflisten und erstellen sowie Objekte hochladen, herunterladen, umbenennen oder löschen, während RustFS die Berechtigungen des authentifizierten Benutzers von Identity and Access Management (IAM) durchsetzt. -SFTP is an optional compile-time feature and is not included in the default RustFS build. Build RustFS with the `sftp` or `full` feature before enabling the listener. The listener is disabled at runtime by default. +SFTP ist ein optionales Feature zur Build-Zeit und nicht im Standard-Build von RustFS enthalten. Bauen Sie RustFS mit dem Feature `sftp` oder `full`, bevor Sie den Listener aktivieren. Der Listener ist zur Laufzeit standardmäßig deaktiviert. -## Overview +## Überblick -The gateway maps SFTP paths to RustFS resources: +Das Gateway bildet SFTP-Pfade auf RustFS-Ressourcen ab: -| SFTP path | RustFS resource | +| SFTP-Pfad | RustFS-Ressource | | --- | --- | -| `/` | All buckets visible to the authenticated user | -| `/my-bucket/` | The `my-bucket` bucket | -| `/my-bucket/hello.txt` | The `hello.txt` object in `my-bucket` | -| `/my-bucket/docs/hello.txt` | The `docs/hello.txt` object in `my-bucket` | +| `/` | Alle Buckets, die für den authentifizierten Benutzer sichtbar sind | +| `/my-bucket/` | Der Bucket `my-bucket` | +| `/my-bucket/hello.txt` | Das Objekt `hello.txt` in `my-bucket` | +| `/my-bucket/docs/hello.txt` | Das Objekt `docs/hello.txt` in `my-bucket` | -Creating or removing a directory directly below `/` creates or removes a bucket. Directories below a bucket map to object key prefixes and do not exist as independent filesystem directories. +Das Erstellen oder Entfernen eines Verzeichnisses direkt unter `/` erstellt oder entfernt einen Bucket. Verzeichnisse unterhalb eines Buckets werden auf Präfixe von Objektschlüsseln abgebildet und existieren nicht als eigenständige Dateisystemverzeichnisse. -RustFS supports the following operations through the SFTP gateway: +RustFS unterstützt die folgenden Operationen über das SFTP-Gateway: -| SFTP operation | RustFS operation | +| SFTP-Operation | RustFS-Operation | | --- | --- | -| List `/` | List visible buckets | -| List a bucket or prefix | List objects and prefixes | -| `mkdir` at `/` | Create a bucket | -| `put` | Upload an object | -| `get` | Download an object | -| `rename` | Copy an object and then delete the source | -| `rm` | Delete an object | -| `rmdir` at `/` | Delete an empty bucket | +| `/` auflisten | Sichtbare Buckets auflisten | +| Bucket oder Präfix auflisten | Objekte und Präfixe auflisten | +| `mkdir` unter `/` | Bucket erstellen | +| `put` | Objekt hochladen | +| `get` | Objekt herunterladen | +| `rename` | Objekt kopieren und anschließend die Quelle löschen | +| `rm` | Objekt löschen | +| `rmdir` unter `/` | Leeren Bucket löschen | -Enter a RustFS access key as the SFTP username and its secret key as the password. RustFS checks the IAM user's S3 policies for every operation. +Geben Sie einen RustFS-Zugriffsschlüssel als SFTP-Benutzernamen und den zugehörigen geheimen Zugriffsschlüssel als Passwort ein. RustFS prüft die S3-Richtlinien des IAM-Benutzers für jede Operation. -:::warning[Password authentication only] +:::warning[Nur Passwortauthentifizierung] -The SFTP gateway does not support client public-key authentication or anonymous access. SSH host keys identify the server; they do not authenticate clients. Do not configure an `authorized_keys` file for RustFS SFTP. +Das SFTP-Gateway unterstützt keine Authentifizierung mit öffentlichen Client-Schlüsseln und keinen anonymen Zugriff. SSH-Host-Schlüssel identifizieren den Server. Sie authentifizieren keine Clients. Konfigurieren Sie für RustFS-SFTP keine Datei `authorized_keys`. ::: -## Configuration +## Konfiguration -### Build with SFTP support +### Mit SFTP-Unterstützung bauen -Build RustFS with the SFTP feature: +Bauen Sie RustFS mit dem SFTP-Feature: ```bash cargo build --release --features sftp ``` -To enable all optional RustFS features, including SFTP, use `--features full` instead. Setting `RUSTFS_SFTP_ENABLE=true` has no effect in a binary built without the `sftp` feature. +Um alle optionalen RustFS-Features einschließlich SFTP zu aktivieren, verwenden Sie stattdessen `--features full`. `RUSTFS_SFTP_ENABLE=true` hat in einem Binary ohne das Feature `sftp` keine Wirkung. -### SFTP variables +### SFTP-Variablen -| Variable | Description | Default | +| Variable | Beschreibung | Standard | | --- | --- | --- | -| `RUSTFS_SFTP_ENABLE` | Enables the SFTP listener. | `false` | -| `RUSTFS_SFTP_ADDRESS` | Bind address for SFTP connections. | `0.0.0.0:2222` | -| `RUSTFS_SFTP_HOST_KEY_DIR` | Directory containing at least one unencrypted SSH private host key. Required when SFTP is enabled. | Not set | -| `RUSTFS_SFTP_READ_ONLY` | Rejects operations that modify buckets or objects. | `false` | -| `RUSTFS_SFTP_IDLE_TIMEOUT` | SSH inactivity timeout in seconds. Must be greater than zero. | `600` | -| `RUSTFS_SFTP_PART_SIZE` | Multipart upload part size in bytes. | `16777216` (16 MiB) | +| `RUSTFS_SFTP_ENABLE` | Aktiviert den SFTP-Listener. | `false` | +| `RUSTFS_SFTP_ADDRESS` | Bind-Adresse für SFTP-Verbindungen. | `0.0.0.0:2222` | +| `RUSTFS_SFTP_HOST_KEY_DIR` | Verzeichnis mit mindestens einem unverschlüsselten privaten SSH-Host-Schlüssel. Erforderlich, wenn SFTP aktiviert ist. | Nicht gesetzt | +| `RUSTFS_SFTP_READ_ONLY` | Lehnt Operationen ab, die Buckets oder Objekte ändern. | `false` | +| `RUSTFS_SFTP_IDLE_TIMEOUT` | SSH-Inaktivitätszeitlimit in Sekunden. Muss größer als null sein. | `600` | +| `RUSTFS_SFTP_PART_SIZE` | Teilgröße des mehrteiligen Uploads in Bytes. | `16777216` (16 MiB) | -The default port `2222` avoids the privileged SSH port `22`. The address can use IPv4 or IPv6 syntax, for example `127.0.0.1:2222` or `[::]:2222`. +Der Standardport `2222` vermeidet den privilegierten SSH-Port `22`. Die Adresse kann IPv4- oder IPv6-Syntax verwenden, zum Beispiel `127.0.0.1:2222` oder `[::]:2222`. -### Prepare a host key +### Host-Schlüssel vorbereiten -Create a persistent host-key directory and generate an Ed25519 host key: +Erstellen Sie ein dauerhaftes Verzeichnis für Host-Schlüssel und erzeugen Sie einen Ed25519-Host-Schlüssel: ```bash mkdir -p /path/to/sftp-keys @@ -78,19 +78,19 @@ ssh-keygen -t ed25519 \ chmod 600 /path/to/sftp-keys/ssh_host_ed25519_key* ``` -The host key must not use a passphrase. RustFS also accepts decodable ECDSA and RSA private host keys. +Der Host-Schlüssel darf keine Passphrase verwenden. RustFS akzeptiert außerdem private ECDSA- und RSA-Host-Schlüssel, die es einlesen kann. -On Unix, every regular file in the host-key directory must be accessible only by its owner. The `ssh-keygen` command also creates a `.pub` file; either keep it with owner-only permissions as shown or remove it because RustFS does not read it. RustFS refuses to start if the directory is missing, contains no usable private key, or contains a regular file with group or other permission bits set. +Unter Unix darf jede reguläre Datei im Verzeichnis der Host-Schlüssel nur für ihren Eigentümer zugänglich sein. Der Befehl `ssh-keygen` erzeugt außerdem eine `.pub`-Datei. Belassen Sie sie wie gezeigt mit Berechtigungen nur für den Eigentümer oder entfernen Sie sie, weil RustFS sie nicht liest. RustFS verweigert den Start, wenn das Verzeichnis fehlt, keinen verwendbaren privaten Schlüssel enthält oder eine reguläre Datei enthält, bei der Bits für die Gruppe oder für andere Benutzer gesetzt sind. -:::warning[Protect the host key] +:::warning[Host-Schlüssel schützen] -Keep the same host key across restarts so clients can verify the server identity. Restrict access to the account that runs RustFS and back up the key securely. A changed host key causes clients to display a possible man-in-the-middle warning. +Behalten Sie denselben Host-Schlüssel über Neustarts hinweg, damit Clients die Serveridentität prüfen können. Beschränken Sie den Zugriff auf das Konto, unter dem RustFS läuft, und sichern Sie den Schlüssel geschützt. Ein geänderter Host-Schlüssel führt dazu, dass Clients eine mögliche Man-in-the-Middle-Warnung anzeigen. ::: -### Start the SFTP listener +### SFTP-Listener starten -The following example starts SFTP on the loopback interface for local testing: +Das folgende Beispiel startet SFTP für lokale Tests auf der Loopback-Schnittstelle: ```bash export RUSTFS_SFTP_ENABLE=true @@ -102,23 +102,23 @@ export RUSTFS_SECRET_KEY= rustfs /path/to/data ``` -For remote connections, bind to an appropriate network interface and allow inbound TCP traffic to the configured SFTP port. This listener is separate from the S3 API and Console listeners. +Binden Sie für entfernte Verbindungen an eine passende Netzwerkschnittstelle und lassen Sie eingehenden TCP-Verkehr zum konfigurierten SFTP-Port zu. Dieser Listener ist von den Listenern der S3-API und der Console getrennt. -## Usage +## Verwendung -The following examples use the OpenSSH `sftp` client, the canonical `my-bucket` and `hello.txt` names, and a local listener on port `2222`. +Die folgenden Beispiele verwenden den OpenSSH-Client `sftp`, die kanonischen Namen `my-bucket` und `hello.txt` sowie einen lokalen Listener auf Port `2222`. -### Connect +### Verbinden ```bash sftp -P 2222 @127.0.0.1 ``` -Enter the RustFS secret key when prompted for the password. On the first connection, verify the displayed host-key fingerprint before accepting it. +Geben Sie den geheimen Zugriffsschlüssel von RustFS ein, wenn nach dem Passwort gefragt wird. Prüfen Sie bei der ersten Verbindung den angezeigten Fingerabdruck des Host-Schlüssels, bevor Sie ihn akzeptieren. -### List and create buckets +### Buckets auflisten und erstellen -At the `sftp` prompt, list the buckets visible to the IAM user and create `my-bucket`: +Listen Sie an der `sftp`-Eingabeaufforderung die für den IAM-Benutzer sichtbaren Buckets auf und erstellen Sie `my-bucket`: ```text sftp> ls / @@ -126,11 +126,11 @@ sftp> mkdir /my-bucket sftp> cd /my-bucket ``` -Bucket names must follow the same naming rules as buckets created through the S3 API. Files cannot be created directly under `/`. +Bucket-Namen müssen denselben Namensregeln folgen wie Buckets, die über die S3-API erstellt werden. Objekte können nicht direkt unter `/` angelegt werden. -### Upload and download an object +### Objekt hochladen und herunterladen -Upload `/path/to/hello.txt`, list the bucket, and download the object: +Laden Sie `/path/to/hello.txt` hoch, listen Sie den Bucket auf und laden Sie das Objekt herunter: ```text sftp> put /path/to/hello.txt /my-bucket/hello.txt @@ -138,44 +138,44 @@ sftp> ls /my-bucket sftp> get /my-bucket/hello.txt hello.txt ``` -Uploads must be sequential from the beginning of the file. Resume, append, in-place edits, and segmented multi-connection uploads of one object are not supported. +Uploads müssen sequenziell vom Anfang der Datei erfolgen. Fortsetzen, Anfügen, Änderungen an Ort und Stelle und segmentierte Uploads eines Objekts über mehrere Verbindungen werden nicht unterstützt. -### Rename an object +### Objekt umbenennen ```text sftp> rename /my-bucket/hello.txt /my-bucket/greeting.txt ``` -RustFS implements rename as a server-side copy followed by deletion of the source. The operation is not atomic, and renaming a bucket is not supported. The IAM user needs permission to read and delete the source and to write the destination. +RustFS implementiert das Umbenennen als serverseitige Kopie mit anschließendem Löschen der Quelle. Die Operation ist nicht atomar, und das Umbenennen eines Buckets wird nicht unterstützt. Der IAM-Benutzer benötigt die Berechtigung, die Quelle zu lesen und zu löschen und das Ziel zu schreiben. -### Delete an object and bucket +### Objekt und Bucket löschen -Delete the object and then remove the empty bucket: +Löschen Sie das Objekt und entfernen Sie anschließend den leeren Bucket: ```text sftp> rm /my-bucket/greeting.txt sftp> rmdir /my-bucket ``` -RustFS does not recursively delete a non-empty bucket through SFTP. +RustFS löscht einen nicht leeren Bucket über SFTP nicht rekursiv. -### Connect a desktop client +### Desktop-Client verbinden -Use these settings in graphical clients such as FileZilla, Cyberduck, or WinSCP: +Verwenden Sie diese Einstellungen in grafischen Clients wie FileZilla, Cyberduck oder WinSCP: -| Setting | Value | +| Einstellung | Wert | | --- | --- | -| Protocol | SFTP (SSH File Transfer Protocol) | -| Host | Your RustFS SFTP hostname | -| Port | `2222`, or the port in `RUSTFS_SFTP_ADDRESS` | -| Username | RustFS access key | -| Password | RustFS secret key | -| Authentication | Password | +| Protokoll | SFTP (SSH File Transfer Protocol) | +| Host | Ihr RustFS-SFTP-Hostname | +| Port | `2222` oder der Port in `RUSTFS_SFTP_ADDRESS` | +| Benutzername | RustFS-Zugriffsschlüssel | +| Passwort | Geheimer Zugriffsschlüssel von RustFS | +| Authentifizierung | Passwort | -Configure the client for whole-file, single-connection uploads. Symbolic links and POSIX ownership, permission, or timestamp changes are not supported because the gateway maps SFTP operations to object storage. +Konfigurieren Sie den Client für Uploads der vollständigen Datei über eine einzelne Verbindung. Symbolische Links sowie Änderungen an POSIX-Eigentümerschaft, Berechtigungen oder Zeitstempeln werden nicht unterstützt, weil das Gateway SFTP-Operationen auf Objektspeicher abbildet. -## Next steps +## Nächste Schritte -- [Manage credentials](/operations/credentials) -- [Check service status](/operations/status-check) -- [Configure lifecycle management](/administration/data/lifecycle-management) \ No newline at end of file +- [Zugangsdaten verwalten](/de/operations/credentials) +- [Dienststatus prüfen](/de/operations/status-check) +- [Lebenszyklusverwaltung konfigurieren](/de/administration/data/lifecycle-management) diff --git a/content/de/administration/protocols/webdav.md b/content/de/administration/protocols/webdav.md index ab6a80ff7..7cea3ace8 100644 --- a/content/de/administration/protocols/webdav.md +++ b/content/de/administration/protocols/webdav.md @@ -1,66 +1,66 @@ --- title: "WebDAV" -description: "Configure the RustFS WebDAV gateway and access buckets and objects with WebDAV clients." +description: "Konfigurieren Sie das WebDAV-Gateway von RustFS und greifen Sie mit WebDAV-Clients auf Buckets und Objekte zu." --- -RustFS includes a Web Distributed Authoring and Versioning (WebDAV) gateway that exposes buckets and objects to WebDAV clients over HTTP or HTTPS. You can browse buckets, create collections, and upload, download, rename, or delete objects while RustFS enforces the permissions of the authenticated Identity and Access Management (IAM) user. +RustFS enthält ein Gateway für Web Distributed Authoring and Versioning (WebDAV), das Buckets und Objekte über HTTP oder HTTPS für WebDAV-Clients bereitstellt. Sie können Buckets durchsuchen, Sammlungen erstellen und Objekte hochladen, herunterladen, umbenennen oder löschen, während RustFS die Berechtigungen des authentifizierten Benutzers von Identity and Access Management (IAM) durchsetzt. -WebDAV support is compiled into the standard RustFS binary, but the gateway is disabled at runtime by default. You must enable and configure it before connecting a client. +Die WebDAV-Unterstützung ist im Standard-Binary von RustFS enthalten, das Gateway ist zur Laufzeit jedoch standardmäßig deaktiviert. Sie müssen es aktivieren und konfigurieren, bevor Sie einen Client verbinden. -## Overview +## Überblick -The gateway maps WebDAV paths to RustFS resources: +Das Gateway bildet WebDAV-Pfade auf RustFS-Ressourcen ab: -| WebDAV path | RustFS resource | +| WebDAV-Pfad | RustFS-Ressource | | --- | --- | -| `/` | All buckets visible to the authenticated user | -| `/my-bucket/` | The `my-bucket` bucket | -| `/my-bucket/hello.txt` | The `hello.txt` object in `my-bucket` | -| `/my-bucket/docs/hello.txt` | The `docs/hello.txt` object in `my-bucket` | +| `/` | Alle Buckets, die für den authentifizierten Benutzer sichtbar sind | +| `/my-bucket/` | Der Bucket `my-bucket` | +| `/my-bucket/hello.txt` | Das Objekt `hello.txt` in `my-bucket` | +| `/my-bucket/docs/hello.txt` | Das Objekt `docs/hello.txt` in `my-bucket` | -RustFS supports the following operations through the gateway: +RustFS unterstützt die folgenden Operationen über das Gateway: -| Method | Operation | +| Methode | Operation | | --- | --- | -| `PROPFIND` | List buckets or objects and read metadata | -| `MKCOL` | Create a bucket or a directory prefix | -| `PUT` | Upload an object | -| `GET` | Download an object | -| `HEAD` | Read object metadata | -| `MOVE` | Rename or move an object or directory | -| `DELETE` | Delete an object, directory, or bucket | +| `PROPFIND` | Buckets oder Objekte auflisten und Metadaten lesen | +| `MKCOL` | Bucket oder Verzeichnispräfix erstellen | +| `PUT` | Objekt hochladen | +| `GET` | Objekt herunterladen | +| `HEAD` | Objektmetadaten abrufen | +| `MOVE` | Objekt oder Verzeichnis umbenennen oder verschieben | +| `DELETE` | Objekt, Verzeichnis oder Bucket löschen | -Use `PROPFIND`, not `GET`, to list a collection. The current gateway returns `405 Method Not Allowed` for `GET` requests to directories. +Listen Sie eine Sammlung mit `PROPFIND` auf, nicht mit `GET`. Das aktuelle Gateway gibt für `GET`-Anfragen an Verzeichnisse `405 Method Not Allowed` zurück. -WebDAV uses HTTP Basic authentication. Enter a RustFS access key as the username and its secret key as the password. The gateway authenticates the credentials against RustFS IAM and applies the user's S3 policies to each operation. +WebDAV verwendet die HTTP-Basic-Authentifizierung. Geben Sie einen RustFS-Zugriffsschlüssel als Benutzernamen und den zugehörigen geheimen Zugriffsschlüssel als Passwort ein. Das Gateway authentifiziert die Zugangsdaten gegen RustFS-IAM und wendet die S3-Richtlinien des Benutzers auf jede Operation an. -:::warning[Protect credentials] +:::warning[Zugangsdaten schützen] -Basic authentication does not encrypt credentials. Disable TLS only for isolated local testing. Use HTTPS for every remote or production connection. +Die Basic-Authentifizierung verschlüsselt Zugangsdaten nicht. Deaktivieren Sie TLS nur für isolierte lokale Tests. Verwenden Sie HTTPS für jede entfernte oder produktive Verbindung. ::: -## Configuration +## Konfiguration -Configure the gateway with environment variables before starting RustFS: +Konfigurieren Sie das Gateway mit Umgebungsvariablen, bevor Sie RustFS starten: -| Variable | Description | Default | +| Variable | Beschreibung | Standard | | --- | --- | --- | -| `RUSTFS_WEBDAV_ENABLE` | Enables the WebDAV gateway. | `false` | -| `RUSTFS_WEBDAV_ADDRESS` | Bind address for WebDAV connections. | `0.0.0.0:8080` | -| `RUSTFS_WEBDAV_TLS_ENABLED` | Enables TLS for the WebDAV listener. | `true` | -| `RUSTFS_WEBDAV_CERTS_DIR` | Certificate directory used by the RustFS TLS runtime. Required when TLS is enabled. | Not set | -| `RUSTFS_WEBDAV_MAX_BODY_SIZE` | Maximum request body size in bytes. Must be greater than zero. | `5368709120` (5 GiB) | +| `RUSTFS_WEBDAV_ENABLE` | Aktiviert das WebDAV-Gateway. | `false` | +| `RUSTFS_WEBDAV_ADDRESS` | Bind-Adresse für WebDAV-Verbindungen. | `0.0.0.0:8080` | +| `RUSTFS_WEBDAV_TLS_ENABLED` | Aktiviert TLS für den WebDAV-Listener. | `true` | +| `RUSTFS_WEBDAV_CERTS_DIR` | Zertifikatsverzeichnis, das die TLS-Laufzeit von RustFS verwendet. Erforderlich, wenn TLS aktiviert ist. | Nicht gesetzt | +| `RUSTFS_WEBDAV_MAX_BODY_SIZE` | Maximale Größe des Anfragekörpers in Bytes. Muss größer als null sein. | `5368709120` (5 GiB) | -The standard RustFS build enables the WebDAV compile-time feature. If you build RustFS with `--no-default-features`, include the feature explicitly: +Der Standard-Build von RustFS aktiviert das WebDAV-Feature zur Build-Zeit. Wenn Sie RustFS mit `--no-default-features` bauen, nehmen Sie das Feature ausdrücklich auf: ```bash cargo build --release --features webdav ``` -### Local testing without TLS +### Lokale Tests ohne TLS -The following example starts RustFS with an HTTP WebDAV listener on port `8080`: +Das folgende Beispiel startet RustFS mit einem HTTP-WebDAV-Listener auf Port `8080`: ```bash export RUSTFS_WEBDAV_ENABLE=true @@ -72,11 +72,11 @@ export RUSTFS_SECRET_KEY= rustfs /path/to/data ``` -Binding to `127.0.0.1` prevents other hosts from connecting to the unencrypted test endpoint. +Die Bindung an `127.0.0.1` verhindert, dass andere Hosts eine Verbindung zum unverschlüsselten Testendpunkt aufbauen. ### HTTPS -For a remote or production connection, enable TLS and provide a certificate directory: +Aktivieren Sie für eine entfernte oder produktive Verbindung TLS und geben Sie ein Zertifikatsverzeichnis an: ```bash export RUSTFS_WEBDAV_ENABLE=true @@ -87,15 +87,15 @@ export RUSTFS_WEBDAV_CERTS_DIR=/path/to/certs rustfs /path/to/data ``` -If TLS is enabled without `RUSTFS_WEBDAV_CERTS_DIR`, or the directory does not exist, WebDAV initialization fails. See [Configure TLS](/integration/tls-configured) for certificate preparation guidance. +Wenn TLS ohne `RUSTFS_WEBDAV_CERTS_DIR` aktiviert ist oder das Verzeichnis nicht vorhanden ist, schlägt die WebDAV-Initialisierung fehl. Hinweise zur Zertifikatsvorbereitung stehen unter [TLS konfigurieren](/de/integration/tls-configured). -Allow inbound TCP traffic to the configured WebDAV port. This listener is separate from the S3 API and Console listeners. +Lassen Sie eingehenden TCP-Verkehr zum konfigurierten WebDAV-Port zu. Dieser Listener ist von den Listenern der S3-API und der Console getrennt. -## Usage +## Verwendung -The following commands use an HTTP endpoint for local testing. Replace the endpoint and credentials with your HTTPS WebDAV endpoint and an IAM user that has the required bucket and object permissions. +Die folgenden Befehle verwenden einen HTTP-Endpunkt für lokale Tests. Ersetzen Sie den Endpunkt und die Zugangsdaten durch Ihren HTTPS-WebDAV-Endpunkt und einen IAM-Benutzer mit den erforderlichen Bucket- und Objektberechtigungen. -Set reusable shell variables without placing the secret directly in each command: +Setzen Sie wiederverwendbare Shell-Variablen, ohne das Geheimnis direkt in jeden Befehl zu schreiben: ```bash export WEBDAV_URL=http://127.0.0.1:8080 @@ -104,9 +104,9 @@ read -s WEBDAV_PASSWORD export WEBDAV_PASSWORD ``` -### List buckets +### Buckets auflisten -Send `PROPFIND` with `Depth: 1` to list the buckets visible to the user: +Senden Sie `PROPFIND` mit `Depth: 1`, um die für den Benutzer sichtbaren Buckets aufzulisten: ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -115,7 +115,7 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/" ``` -### Create a bucket +### Bucket erstellen ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -123,11 +123,11 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/my-bucket/" ``` -Bucket names must follow the same naming rules as buckets created through the S3 API. +Bucket-Namen müssen denselben Namensregeln folgen wie Buckets, die über die S3-API erstellt werden. -### Upload and download an object +### Objekt hochladen und herunterladen -Upload `/path/to/hello.txt`: +Laden Sie `/path/to/hello.txt` hoch: ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -135,7 +135,7 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/my-bucket/hello.txt" ``` -Download the object: +Laden Sie das Objekt herunter: ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -143,9 +143,9 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/my-bucket/hello.txt" ``` -### Create and list a directory +### Verzeichnis erstellen und auflisten -WebDAV directories below a bucket map to object key prefixes: +WebDAV-Verzeichnisse unterhalb eines Buckets werden auf Präfixe von Objektschlüsseln abgebildet: ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -158,9 +158,9 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/my-bucket/docs/" ``` -### Rename an object +### Objekt umbenennen -Use `MOVE` with a destination path on the same WebDAV endpoint: +Verwenden Sie `MOVE` mit einem Zielpfad auf demselben WebDAV-Endpunkt: ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -169,11 +169,11 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/my-bucket/hello.txt" ``` -The IAM user needs permission to read and delete the source and to write the destination. If authorization fails, RustFS leaves the source unchanged. +Der IAM-Benutzer benötigt die Berechtigung, die Quelle zu lesen und zu löschen und das Ziel zu schreiben. Wenn die Autorisierung fehlschlägt, lässt RustFS die Quelle unverändert. -### Delete an object or bucket +### Objekt oder Bucket löschen -Delete an object: +Löschen Sie ein Objekt: ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -181,7 +181,7 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/my-bucket/greeting.txt" ``` -Delete the bucket after removing its contents: +Löschen Sie den Bucket, nachdem Sie seinen Inhalt entfernt haben: ```bash curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ @@ -189,20 +189,20 @@ curl --user "$WEBDAV_USER:$WEBDAV_PASSWORD" \ "$WEBDAV_URL/my-bucket/" ``` -### Connect a desktop client +### Desktop-Client verbinden -Use the WebDAV endpoint in a client that supports Basic authentication: +Verwenden Sie den WebDAV-Endpunkt in einem Client, der Basic-Authentifizierung unterstützt: -| Client | Connection address | +| Client | Verbindungsadresse | | --- | --- | -| GNOME Files | `dav://:8080/` for HTTP or `davs://:8080/` for HTTPS | -| macOS Finder | `http://:8080/` or `https://:8080/` | -| Windows File Explorer | `https://:8080/` | +| GNOME Files | `dav://:8080/` für HTTP oder `davs://:8080/` für HTTPS | +| macOS Finder | `http://:8080/` oder `https://:8080/` | +| Windows-Explorer | `https://:8080/` | -Enter the RustFS access key and secret key when the client prompts for credentials. Client behavior and supported WebDAV methods vary; use `curl` to isolate server-side errors when troubleshooting. +Geben Sie den RustFS-Zugriffsschlüssel und den geheimen Zugriffsschlüssel ein, wenn der Client nach Anmeldedaten fragt. Das Verhalten des Clients und die unterstützten WebDAV-Methoden unterscheiden sich. Verwenden Sie `curl`, um serverseitige Fehler bei der Fehlerbehebung einzugrenzen. -## Next steps +## Nächste Schritte -- [Manage credentials](/operations/credentials) -- [Configure TLS](/integration/tls-configured) -- [Check service status](/operations/status-check) \ No newline at end of file +- [Zugangsdaten verwalten](/de/operations/credentials) +- [TLS konfigurieren](/de/integration/tls-configured) +- [Dienststatus prüfen](/de/operations/status-check) diff --git a/content/de/developer/examples/aws-cli.md b/content/de/developer/examples/aws-cli.md index 2e7dad35b..d255503e4 100644 --- a/content/de/developer/examples/aws-cli.md +++ b/content/de/developer/examples/aws-cli.md @@ -1,21 +1,21 @@ --- title: "AWS CLI" -description: "Connect the AWS CLI to RustFS and perform basic object operations." +description: "Verbinden Sie die AWS CLI mit RustFS und führen Sie grundlegende Objektoperationen aus." --- -The [AWS CLI](https://docs.aws.amazon.com/cli/) is Amazon's official command-line tool for S3, and it works with RustFS via the `--endpoint-url` flag. +Die [AWS CLI](https://docs.aws.amazon.com/cli/) ist das offizielle Befehlszeilenwerkzeug von Amazon für S3 und funktioniert mit RustFS über das Flag `--endpoint-url`. -## Install +## Installation -Follow the [official install guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html), or on macOS: +Folgen Sie der [offiziellen Installationsanleitung](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Unter macOS: ```bash brew install awscli ``` -## Configure +## Konfiguration -Set your [access keys](../../security-compliance/iam/access-token.md) and region: +Setzen Sie Ihre [Zugriffsschlüssel](../../security-compliance/iam/access-token.md) und die Region: ```bash aws configure @@ -28,17 +28,17 @@ Default region name [None]: us-east-1 Default output format [None]: json ``` -Pass your RustFS address with `--endpoint-url` on every command. Replace `http://localhost:9000` with your server address. When `--endpoint-url` is set, the AWS CLI uses path-style addressing, which is what RustFS requires. +Übergeben Sie bei jedem Befehl die RustFS-Adresse mit `--endpoint-url`. Ersetzen Sie `http://localhost:9000` durch Ihre Serveradresse. Wenn `--endpoint-url` gesetzt ist, verwendet die AWS CLI pfadbasierte Adressierung (Path-Style). Das ist die Adressierung, die RustFS erwartet. :::note -If you did not set credentials at install, the local-test default is `rustfsadmin` / `rustfsadmin` — never use it beyond a throwaway local trial. +Wenn Sie bei der Installation keine Anmeldedaten gesetzt haben, lautet der Standard für lokale Tests `rustfsadmin` / `rustfsadmin`. Verwenden Sie ihn niemals außerhalb eines wegwerfbaren lokalen Tests. ::: -## Verify +## Überprüfung -Create a bucket: +Erstellen Sie einen Bucket: ```bash aws s3 mb s3://my-bucket --endpoint-url http://localhost:9000 @@ -48,7 +48,7 @@ aws s3 mb s3://my-bucket --endpoint-url http://localhost:9000 make_bucket: my-bucket ``` -Upload a file: +Laden Sie eine Datei hoch: ```bash aws s3 cp /path/to/hello.txt s3://my-bucket/ --endpoint-url http://localhost:9000 @@ -58,7 +58,7 @@ aws s3 cp /path/to/hello.txt s3://my-bucket/ --endpoint-url http://localhost:900 upload: ../path/to/hello.txt to s3://my-bucket/hello.txt ``` -List the bucket: +Listen Sie den Bucket auf: ```bash aws s3 ls s3://my-bucket --endpoint-url http://localhost:9000 @@ -68,6 +68,6 @@ aws s3 ls s3://my-bucket --endpoint-url http://localhost:9000 2026-07-15 10:30:00 12 hello.txt ``` -## Next steps +## Nächste Schritte -Build applications against RustFS with an [S3 SDK](../sdk/index.md), or manage objects with [`rc`](/operations/rc). +Schreiben Sie Anwendungen, die RustFS verwenden, mit einem [S3-SDK](../sdk/index.md), oder verwalten Sie Objekte mit [`rc`](/de/operations/rc). diff --git a/content/de/developer/examples/aws-sdk-go.md b/content/de/developer/examples/aws-sdk-go.md index 70958b90c..7a1c2d953 100644 --- a/content/de/developer/examples/aws-sdk-go.md +++ b/content/de/developer/examples/aws-sdk-go.md @@ -1,11 +1,11 @@ --- -title: "AWS SDK for Go" -description: "Connect the AWS SDK for Go v2 to RustFS and perform basic object operations." +title: "AWS SDK für Go" +description: "Verbinden Sie das AWS SDK für Go v2 mit RustFS und führen Sie grundlegende Objektoperationen aus." --- -The [AWS SDK for Go v2](https://aws.github.io/aws-sdk-go-v2/docs/) connects to RustFS through a custom base endpoint. This is the minimal connection recipe; see the [Go SDK guide](../sdk/go.md) for a full program. +Das [AWS SDK für Go v2](https://aws.github.io/aws-sdk-go-v2/docs/) verbindet sich über einen benutzerdefinierten Basis-Endpunkt mit RustFS. Dies ist das minimale Verbindungsbeispiel. Ein vollständiges Programm steht in der [Go-SDK-Anleitung](../sdk/go.md). -## Install +## Installation ```bash go get github.com/aws/aws-sdk-go-v2/aws @@ -13,9 +13,9 @@ go get github.com/aws/aws-sdk-go-v2/credentials go get github.com/aws/aws-sdk-go-v2/service/s3 ``` -## Configure +## Konfiguration -Replace `http://localhost:9000` with your server address and use your own [access keys](../../security-compliance/iam/access-token.md). RustFS requires path-style addressing (`UsePathStyle: true`): +Ersetzen Sie `http://localhost:9000` durch Ihre Serveradresse und verwenden Sie Ihre eigenen [Zugriffsschlüssel](../../security-compliance/iam/access-token.md). RustFS erfordert pfadbasierte Adressierung (Path-Style) (`UsePathStyle: true`): ```go {9,11} import ( @@ -34,7 +34,7 @@ client := s3.NewFromConfig(cfg, func(o *s3.Options) { }) ``` -## Verify +## Überprüfung ```go ctx := context.Background() @@ -50,6 +50,6 @@ for _, b := range out.Buckets { my-bucket ``` -## Next steps +## Nächste Schritte -See the full [Go SDK guide](../sdk/go.md), or manage objects with [`rc`](/operations/rc). +Lesen Sie die vollständige [Go-SDK-Anleitung](../sdk/go.md), oder verwalten Sie Objekte mit [`rc`](/de/operations/rc). diff --git a/content/de/developer/examples/aws-sdk-js.md b/content/de/developer/examples/aws-sdk-js.md index 408757a10..c84e5e9fd 100644 --- a/content/de/developer/examples/aws-sdk-js.md +++ b/content/de/developer/examples/aws-sdk-js.md @@ -1,19 +1,19 @@ --- -title: "AWS SDK for JavaScript" -description: "Connect the AWS SDK for JavaScript v3 to RustFS and perform basic object operations from Node.js." +title: "AWS SDK für JavaScript" +description: "Verbinden Sie das AWS SDK für JavaScript v3 mit RustFS und führen Sie grundlegende Objektoperationen aus Node.js aus." --- -The [AWS SDK for JavaScript v3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) connects to RustFS through a custom endpoint. This is the minimal connection recipe; see the [JavaScript SDK guide](../sdk/javascript.md) for a full program. +Das [AWS SDK für JavaScript v3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) verbindet sich über einen benutzerdefinierten Endpunkt mit RustFS. Dies ist das minimale Verbindungsbeispiel. Ein vollständiges Programm steht in der [JavaScript-SDK-Anleitung](../sdk/javascript.md). -## Install +## Installation ```bash npm install @aws-sdk/client-s3 ``` -## Configure +## Konfiguration -Replace `http://localhost:9000` with your server address and use your own [access keys](../../security-compliance/iam/access-token.md). RustFS requires path-style addressing (`forcePathStyle: true`): +Ersetzen Sie `http://localhost:9000` durch Ihre Serveradresse und verwenden Sie Ihre eigenen [Zugriffsschlüssel](../../security-compliance/iam/access-token.md). RustFS erfordert pfadbasierte Adressierung (Path-Style) (`forcePathStyle: true`): ```javascript title="index.mjs" {8} import { S3Client, CreateBucketCommand, PutObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3"; @@ -27,7 +27,7 @@ const s3 = new S3Client({ }); ``` -## Verify +## Überprüfung ```javascript await s3.send(new CreateBucketCommand({ Bucket: "my-bucket" })); @@ -41,6 +41,6 @@ for (const obj of out.Contents ?? []) console.log(obj.Key, obj.Size); hello.txt 12 ``` -## Next steps +## Nächste Schritte -See the full [JavaScript SDK guide](../sdk/javascript.md), or manage objects with [`rc`](/operations/rc). +Lesen Sie die vollständige [JavaScript-SDK-Anleitung](../sdk/javascript.md), oder verwalten Sie Objekte mit [`rc`](/de/operations/rc). diff --git a/content/de/developer/examples/boto3.md b/content/de/developer/examples/boto3.md index 99b812712..673a7851d 100644 --- a/content/de/developer/examples/boto3.md +++ b/content/de/developer/examples/boto3.md @@ -1,19 +1,19 @@ --- title: "boto3 (Python)" -description: "Connect boto3 to RustFS and perform basic object operations from Python." +description: "Verbinden Sie boto3 mit RustFS und führen Sie grundlegende Objektoperationen aus Python aus." --- -[boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) is the AWS SDK for Python and connects to RustFS through a custom endpoint. +[boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) ist das AWS SDK für Python und verbindet sich über einen benutzerdefinierten Endpunkt mit RustFS. -## Install +## Installation ```bash pip install boto3 ``` -## Configure +## Konfiguration -Point the client at your RustFS endpoint. Replace `http://localhost:9000` with your server address, and use your own [access keys](../../security-compliance/iam/access-token.md). RustFS requires path-style addressing, set via botocore `Config`: +Richten Sie den Client auf Ihren RustFS-Endpunkt aus. Ersetzen Sie `http://localhost:9000` durch Ihre Serveradresse und verwenden Sie Ihre eigenen [Zugriffsschlüssel](../../security-compliance/iam/access-token.md). RustFS erfordert pfadbasierte Adressierung (Path-Style). Setzen Sie sie über die botocore-`Config`: ```python import boto3 @@ -29,9 +29,9 @@ s3 = boto3.client( ) ``` -## Verify +## Überprüfung -Create a bucket, upload a file, and list the bucket: +Erstellen Sie einen Bucket, laden Sie eine Datei hoch und listen Sie den Bucket auf: ```python s3.create_bucket(Bucket="my-bucket") @@ -42,12 +42,12 @@ for obj in s3.list_objects_v2(Bucket="my-bucket").get("Contents", []): print(obj["Key"], obj["Size"]) ``` -Expected output: +Erwartete Ausgabe: ```text hello.txt 12 ``` -## Next steps +## Nächste Schritte -See the [S3 SDK overview](../sdk/index.md) for more languages, or manage objects with [`rc`](/operations/rc). If you prefer a community-driven SDK with native async support and full typing, see [capo (Python)](../integration/others/capo.md). +Weitere Sprachen finden Sie in der [S3-SDK-Übersicht](../sdk/index.md). Objekte verwalten Sie mit [`rc`](/de/operations/rc). Wenn Sie ein von der Community entwickeltes SDK mit nativer asynchroner Unterstützung und vollständiger Typisierung bevorzugen, lesen Sie [capo (Python)](../integration/others/capo.md). diff --git a/content/de/developer/examples/meta.json b/content/de/developer/examples/meta.json index 35a973ec1..ebe43928f 100644 --- a/content/de/developer/examples/meta.json +++ b/content/de/developer/examples/meta.json @@ -6,8 +6,8 @@ "[s3cmd](/de/developer/examples/s3cmd)", "[rclone](/de/developer/examples/rclone)", "[boto3 (Python)](/de/developer/examples/boto3)", - "[AWS SDK for JavaScript](/de/developer/examples/aws-sdk-js)", - "[AWS SDK for Go](/de/developer/examples/aws-sdk-go)", + "[AWS SDK für JavaScript](/de/developer/examples/aws-sdk-js)", + "[AWS SDK für Go](/de/developer/examples/aws-sdk-go)", "[Terraform](/de/developer/examples/terraform)" ] } diff --git a/content/de/developer/examples/rclone.md b/content/de/developer/examples/rclone.md index b93bedbf9..ef70dc5c1 100644 --- a/content/de/developer/examples/rclone.md +++ b/content/de/developer/examples/rclone.md @@ -1,21 +1,21 @@ --- title: "rclone" -description: "Connect rclone to RustFS and perform basic object operations." +description: "Verbinden Sie rclone mit RustFS und führen Sie grundlegende Objektoperationen aus." --- -[rclone](https://rclone.org/) is a command-line program for syncing files with cloud storage and speaks the S3 protocol that RustFS implements. +[rclone](https://rclone.org/) ist ein Befehlszeilenprogramm zum Synchronisieren von Dateien mit Cloud-Speicher und spricht das S3-Protokoll, das RustFS implementiert. -## Install +## Installation ```bash curl https://rclone.org/install.sh | sudo bash ``` -Or see the [official install guide](https://rclone.org/install/). +Oder lesen Sie die [offizielle Installationsanleitung](https://rclone.org/install/). -## Configure +## Konfiguration -Add a remote to `~/.config/rclone/rclone.conf`. Replace `http://localhost:9000` with your server address, and use your own [access keys](../../security-compliance/iam/access-token.md). `force_path_style = true` is required because RustFS uses path-style addressing: +Fügen Sie in `~/.config/rclone/rclone.conf` ein Remote hinzu. Ersetzen Sie `http://localhost:9000` durch Ihre Serveradresse und verwenden Sie Ihre eigenen [Zugriffsschlüssel](../../security-compliance/iam/access-token.md). `force_path_style = true` ist erforderlich, weil RustFS pfadbasierte Adressierung (Path-Style) verwendet: ```ini title="~/.config/rclone/rclone.conf" [rustfs] @@ -28,21 +28,21 @@ region = us-east-1 force_path_style = true ``` -## Verify +## Überprüfung -Create a bucket: +Erstellen Sie einen Bucket: ```bash rclone mkdir rustfs:my-bucket ``` -Upload a file: +Laden Sie eine Datei hoch: ```bash rclone copy /path/to/hello.txt rustfs:my-bucket ``` -List buckets and contents: +Listen Sie Buckets und Inhalte auf: ```bash rclone lsd rustfs: @@ -54,6 +54,6 @@ rclone ls rustfs:my-bucket 12 hello.txt ``` -## Next steps +## Nächste Schritte -Build applications against RustFS with an [S3 SDK](../sdk/index.md), or manage objects with [`rc`](/operations/rc). +Schreiben Sie Anwendungen, die RustFS verwenden, mit einem [S3-SDK](../sdk/index.md), oder verwalten Sie Objekte mit [`rc`](/de/operations/rc). diff --git a/content/de/developer/examples/s3cmd.md b/content/de/developer/examples/s3cmd.md index 16fbf31c0..489792fbe 100644 --- a/content/de/developer/examples/s3cmd.md +++ b/content/de/developer/examples/s3cmd.md @@ -1,11 +1,11 @@ --- title: "s3cmd" -description: "Connect s3cmd to RustFS and perform basic object operations from the command line." +description: "Verbinden Sie s3cmd mit RustFS und führen Sie grundlegende Objektoperationen über die Befehlszeile aus." --- -[s3cmd](https://s3tools.org/s3cmd) is a command-line client for S3-compatible storage. Point it at your RustFS endpoint with a small config file. +[s3cmd](https://s3tools.org/s3cmd) ist ein Befehlszeilenclient für S3-kompatiblen Speicher. Richten Sie s3cmd mit einer kleinen Konfigurationsdatei auf Ihren RustFS-Endpunkt aus. -## Install +## Installation ```bash # macOS @@ -16,9 +16,9 @@ sudo apt install s3cmd pip install s3cmd ``` -## Configure +## Konfiguration -Create `~/.s3cfg`. Replace `localhost:9000` with your server address and use your own [access keys](../../security-compliance/iam/access-token.md). RustFS uses path-style addressing, so set the bucket host to the same endpoint: +Legen Sie `~/.s3cfg` an. Ersetzen Sie `localhost:9000` durch Ihre Serveradresse und verwenden Sie Ihre eigenen [Zugriffsschlüssel](../../security-compliance/iam/access-token.md). RustFS verwendet pfadbasierte Adressierung (Path-Style). Setzen Sie den Bucket-Host daher auf denselben Endpunkt: ```ini title="~/.s3cfg" [default] @@ -32,13 +32,13 @@ signature_v2 = False :::note -Set `use_https = True` and point at port `9000` if you have [configured TLS](../../integration/tls-configured.md). +Setzen Sie `use_https = True` und verwenden Sie Port `9000`, wenn Sie [TLS eingerichtet](../../integration/tls-configured.md) haben. ::: -## Verify +## Überprüfung -Create a bucket, upload a file, and list it: +Erstellen Sie einen Bucket, laden Sie eine Datei hoch und listen Sie ihn auf: ```bash s3cmd mb s3://my-bucket @@ -51,6 +51,6 @@ upload: '/path/to/hello.txt' -> 's3://my-bucket/hello.txt' [1 of 1] 2026-07-16 10:00 12 s3://my-bucket/hello.txt ``` -## Next steps +## Nächste Schritte -See the [SDK overview](../sdk/index.md) to connect an application, or manage objects with [`rc`](/operations/rc). +Lesen Sie die [SDK-Übersicht](../sdk/index.md), um eine Anwendung anzubinden, oder verwalten Sie Objekte mit [`rc`](/de/operations/rc). diff --git a/content/de/developer/examples/terraform.md b/content/de/developer/examples/terraform.md index 08b7ea2d1..cf5bb0640 100644 --- a/content/de/developer/examples/terraform.md +++ b/content/de/developer/examples/terraform.md @@ -1,13 +1,13 @@ --- title: "Terraform" -description: "Manage RustFS buckets and objects with Terraform using the AWS provider pointed at a custom endpoint." +description: "Verwalten Sie RustFS-Buckets und -Objekte mit Terraform, indem Sie den AWS-Provider auf einen benutzerdefinierten Endpunkt richten." --- -The [Terraform AWS provider](https://registry.terraform.io/providers/hashicorp/aws/latest) works against RustFS when you point its S3 endpoint at your server and enable path-style addressing. +Der [Terraform-AWS-Provider](https://registry.terraform.io/providers/hashicorp/aws/latest) arbeitet mit RustFS, wenn Sie seinen S3-Endpunkt auf Ihren Server richten und pfadbasierte Adressierung (Path-Style) aktivieren. -## Configure +## Konfiguration -Replace `http://localhost:9000` with your server address and use your own [access keys](../../security-compliance/iam/access-token.md). The skip flags stop the provider from calling AWS-only metadata and STS endpoints: +Ersetzen Sie `http://localhost:9000` durch Ihre Serveradresse und verwenden Sie Ihre eigenen [Zugriffsschlüssel](../../security-compliance/iam/access-token.md). Die `skip`-Flags verhindern, dass der Provider Metadaten- und STS-Endpunkte aufruft, die es nur bei AWS gibt: ```hcl title="main.tf" provider "aws" { @@ -35,7 +35,7 @@ resource "aws_s3_object" "hello" { } ``` -## Apply +## Anwenden ```bash terraform init @@ -51,6 +51,6 @@ aws_s3_object.hello: Creation complete after 0s [id=hello.txt] Apply complete! Resources: 2 added, 0 changed, 0 destroyed. ``` -## Next steps +## Nächste Schritte -See the [SDK overview](../sdk/index.md) to connect an application, or the [AWS CLI example](aws-cli.md) for ad-hoc commands. +Lesen Sie die [SDK-Übersicht](../sdk/index.md), um eine Anwendung anzubinden, oder das [AWS-CLI-Beispiel](aws-cli.md) für Ad-hoc-Befehle. diff --git a/content/de/developer/index.md b/content/de/developer/index.md index 5141f84f2..430fad900 100644 --- a/content/de/developer/index.md +++ b/content/de/developer/index.md @@ -1,12 +1,12 @@ --- -title: Developer -description: "Integrate applications with RustFS by using STS, MCP, SDKs, and the S3-compatible API." +title: Entwicklung +description: "Integrieren Sie Anwendungen mit RustFS über STS, MCP, SDKs und die S3-kompatible API." --- -Use this section to integrate applications with RustFS through temporary credentials, the Model Context Protocol (MCP), SDKs, and the S3-compatible API. +In diesem Abschnitt integrieren Sie Anwendungen mit RustFS über temporäre Zugangsdaten, das Model Context Protocol (MCP), SDKs und die S3-kompatible API. -- [Security Token Service (STS)](/security-compliance/iam/sts) explains how to request temporary credentials. -- [MCP](/developer/mcp) connects AI tools and agents to RustFS. -- [SDKs](/developer/sdk) provide language-specific integration examples. -- [Integration guides](/developer/integration) cover proxies and data platforms. -- [S3 API](/administration/protocols/s3) documents client configuration and compatibility considerations. +- [Security Token Service (STS)](/de/security-compliance/iam/sts) erklärt, wie Sie temporäre Zugangsdaten anfordern. +- [MCP](/de/developer/mcp) verbindet KI-Werkzeuge und Agenten mit RustFS. +- [SDKs](/de/developer/sdk) enthalten sprachspezifische Integrationsbeispiele. +- [Integrationsanleitungen](/de/developer/integration) behandeln Proxys und Datenplattformen. +- [S3-API](/de/administration/protocols/s3) dokumentiert die Client-Konfiguration und Kompatibilitätsaspekte. diff --git a/content/de/developer/integration/ai/mlflow.md b/content/de/developer/integration/ai/mlflow.md index 46d3205ef..4cfa1114e 100644 --- a/content/de/developer/integration/ai/mlflow.md +++ b/content/de/developer/integration/ai/mlflow.md @@ -1,13 +1,13 @@ --- title: "MLflow" -description: "Run MLflow with RustFS as the S3 artifact store for experiment tracking, deployed with Docker Compose." +description: "Betreiben Sie MLflow mit RustFS als S3-Artefaktspeicher für das Experiment-Tracking, bereitgestellt mit Docker Compose." --- -This guide connects [MLflow](https://github.com/mlflow/mlflow) — the experiment tracking and model registry platform — to **RustFS** as its S3 artifact store. You will start the MLflow tracking server with Docker Compose, log parameters, metrics, and artifacts from a training run, and verify that the artifacts are stored in RustFS. The workflow was verified with `ghcr.io/mlflow/mlflow:v2.22.1` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [MLflow](https://github.com/mlflow/mlflow) — die Plattform für Experiment-Tracking und die Model Registry — mit **RustFS** als S3-Artefaktspeicher. Sie starten den MLflow-Tracking-Server mit Docker Compose, protokollieren Parameter, Metriken und Artefakte eines Trainingslaufs und prüfen, dass die Artefakte in RustFS gespeichert werden. Der Ablauf wurde mit `ghcr.io/mlflow/mlflow:v2.22.1` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker with the Compose plugin. This deployment is intended for local integration testing, not production. +Sie benötigen Docker mit dem Compose-Plugin. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,18 +16,18 @@ flowchart LR Server -->|"metadata"| DB["SQLite"] ``` -The tracking server keeps experiment and run metadata in SQLite and stores artifacts — model files, plots, reports — directly in RustFS through the `s3://` artifact root. The client needs the same RustFS credentials because it uploads artifacts itself, using boto3 and the `MLFLOW_S3_ENDPOINT_URL` setting. +Der Tracking-Server hält Experiment- und Lauf-Metadaten in SQLite und speichert Artefakte — Modelldateien, Plots und Berichte — über die Artefakt-Wurzel `s3://` direkt in RustFS. Der Client benötigt dieselben RustFS-Zugangsdaten, weil er die Artefakte selbst mit boto3 und der Einstellung `MLFLOW_S3_ENDPOINT_URL` hochlädt. -## 1. Create the project files +## 1. Projektdateien anlegen -Create a working directory: +Erstellen Sie ein Arbeitsverzeichnis: ```bash mkdir rustfs-mlflow cd rustfs-mlflow ``` -Create an environment file and replace both credential placeholders: +Erstellen Sie eine Umgebungsdatei und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= @@ -35,9 +35,9 @@ RUSTFS_SECRET_KEY= MLFLOW_BUCKET=my-bucket ``` -Use dedicated credentials for the artifact bucket. Do not commit `.env` to source control. +Verwenden Sie dedizierte Zugangsdaten für den Artefakt-Bucket. Nehmen Sie `.env` nicht in die Versionsverwaltung auf. -Create the Compose file: +Erstellen Sie die Compose-Datei: ```yaml title="compose.yaml" services: @@ -117,34 +117,34 @@ volumes: mlflow-db: ``` -The `create-bucket` service must run before the server starts because MLflow does not create the bucket. `MLFLOW_S3_ENDPOINT_URL` points the server's boto3 client at RustFS with path-style addressing. The SQLite database lives on a volume so experiment metadata survives restarts; production deployments should use a managed database backend instead. +Der Dienst `create-bucket` muss abgeschlossen sein, bevor der Server startet, weil MLflow den Bucket nicht anlegt. `MLFLOW_S3_ENDPOINT_URL` richtet den boto3-Client des Servers mit pfadbasierter Adressierung (Path-Style) auf RustFS aus. Die SQLite-Datenbank liegt auf einem Volume, damit die Experiment-Metadaten einen Neustart überstehen. Produktivbereitstellungen sollten stattdessen ein verwaltetes Datenbank-Backend verwenden. -## 2. Validate and start the deployment +## 2. Bereitstellung prüfen und starten -Resolve the Compose file before starting containers: +Prüfen Sie die Compose-Datei, bevor Sie Container starten: ```bash docker compose config ``` -Start the services and wait for the tracking server: +Starten Sie die Dienste und warten Sie auf den Tracking-Server: ```bash docker compose up -d docker compose ps ``` -The `create-bucket` service should exit with code `0`, and the MLflow UI should answer on `http://localhost:5000`: +Der Dienst `create-bucket` sollte mit dem Code `0` enden, und die MLflow-Oberfläche sollte unter `http://localhost:5000` antworten: ```bash curl -sf http://localhost:5000/ >/dev/null && echo ready ``` -Open the RustFS Console at `http://localhost:9001` to watch artifacts land in `my-bucket` during the next step. +Öffnen Sie die RustFS Console (Weboberfläche) unter `http://localhost:9001`, um im nächsten Schritt zu sehen, wie die Artefakte in `my-bucket` ankommen. -## 3. Log a training run +## 3. Trainingslauf protokollieren -Create the client script — it runs inside the MLflow image, which ships every dependency: +Erstellen Sie das Client-Skript. Es läuft im MLflow-Image, das alle Abhängigkeiten mitbringt: ```bash title="train_demo.py" {12} import mlflow @@ -163,18 +163,18 @@ with mlflow.start_run(run_name="rustfs-verify") as run: print("artifact_uri:", run.info.artifact_uri) ``` -Copy the script into the running container and execute it with the service environment: +Kopieren Sie das Skript in den laufenden Container und führen Sie es mit der Dienstumgebung aus: ```bash docker compose cp train_demo.py mlflow:/tmp/train_demo.py docker compose exec -w /tmp mlflow python train_demo.py ``` -The `artifact_uri` prints as `s3://my-bucket/mlflow-artifacts///artifacts` — the artifact is uploaded straight to RustFS by the client. +Die Ausgabe von `artifact_uri` lautet `s3://my-bucket/mlflow-artifacts///artifacts`. Der Client lädt das Artefakt direkt nach RustFS hoch. -## 4. Verify artifacts in RustFS +## 4. Artefakte in RustFS prüfen -Read the artifact back through the tracking server, then list the same object in RustFS. Save the following as `verify.py`, replace `` with the identifier printed in step 3, and run it the same way: +Lesen Sie das Artefakt über den Tracking-Server zurück und listen Sie dasselbe Objekt in RustFS auf. Speichern Sie das Folgende als `verify.py`, ersetzen Sie `` durch die in Schritt 3 ausgegebene Kennung und führen Sie das Skript auf dieselbe Weise aus: ```bash title="verify.py" {5} import mlflow @@ -186,59 +186,59 @@ path = client.download_artifacts("", "reports/model-summary.txt") print(open(path).read()) ``` -The download reads the object from RustFS through the tracking server. Then confirm the objects in the bucket: +Der Download liest das Objekt über den Tracking-Server aus RustFS. Prüfen Sie anschließend die Objekte im Bucket: ```bash docker compose exec rustfs /usr/bin/rc ls local/my-bucket/mlflow-artifacts/ -r ``` -The output should include the artifact object: +Die Ausgabe sollte das Artefakt-Objekt enthalten: ```text mlflow-artifacts/1/a1aece9243504f2680a52fba0c32765f/artifacts/reports/model-summary.txt ``` -![MLflow artifacts stored in the RustFS Console](./images/rustfs-mlflow-artifacts.png) +![In der RustFS Console gespeicherte MLflow-Artefakte](./images/rustfs-mlflow-artifacts.png) -Runs, parameters, and metrics survive a server restart because they are stored in SQLite, while the artifacts stay in RustFS: +Läufe, Parameter und Metriken überstehen einen Neustart des Servers, weil sie in SQLite liegen, während die Artefakte in RustFS bleiben: ```bash docker compose restart mlflow docker compose exec -w /tmp mlflow python verify.py ``` -The `list_artifacts` call succeeds again against the restarted server, reading from the same objects in RustFS. +Der Aufruf `list_artifacts` gelingt am neu gestarteten Server erneut und liest dieselben Objekte aus RustFS. -## 5. Stop or reset the deployment +## 5. Bereitstellung anhalten oder zurücksetzen -Stop the containers while keeping all data: +Stoppen Sie die Container und behalten Sie alle Daten: ```bash docker compose down ``` -The RustFS volume keeps the artifact objects and the MLflow volume keeps the metadata database. To delete everything, including the artifacts in RustFS, add `--volumes`. +Das RustFS-Volume behält die Artefakt-Objekte, das MLflow-Volume die Metadaten-Datenbank. Um alles zu löschen, einschließlich der Artefakte in RustFS, fügen Sie `--volumes` hinzu. -## Troubleshooting +## Fehlerbehebung -### `ModuleNotFoundError: No module named 'boto3'` when logging artifacts +### `ModuleNotFoundError: No module named 'boto3'` beim Protokollieren von Artefakten -The client performing `log_artifact` needs boto3 because it uploads directly to S3. Install it in the environment that runs the training script, or run the script inside the MLflow image as shown in step 3. +Der Client, der `log_artifact` ausführt, benötigt boto3, weil er direkt nach S3 hochlädt. Installieren Sie boto3 in der Umgebung, die das Trainingsskript ausführt, oder führen Sie das Skript wie in Schritt 3 im MLflow-Image aus. -### `AccessDenied` or connection errors during artifact upload +### `AccessDenied` oder Verbindungsfehler beim Hochladen von Artefakten -Confirm that `MLFLOW_S3_ENDPOINT_URL` is set in the client environment — without it, boto3 sends requests to real AWS S3. The endpoint must be reachable from the machine running the training script; use `http://localhost:9000` outside the Compose network and `http://rustfs:9000` inside it. +Stellen Sie sicher, dass `MLFLOW_S3_ENDPOINT_URL` in der Client-Umgebung gesetzt ist. Ohne diese Variable sendet boto3 Anfragen an das echte AWS S3. Der Endpunkt muss von dem Rechner aus erreichbar sein, auf dem das Trainingsskript läuft. Verwenden Sie außerhalb des Compose-Netzwerks `http://localhost:9000` und innerhalb `http://rustfs:9000`. -### The server fails to start with a bucket error +### Der Server startet nicht und meldet einen Bucket-Fehler -The artifact bucket must exist before the server starts. Check the `create-bucket` service logs: +Der Artefakt-Bucket muss existieren, bevor der Server startet. Prüfen Sie die Logs des Dienstes `create-bucket`: ```bash docker compose logs create-bucket ``` -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional MLflow operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [MLflow documentation](https://mlflow.org/docs/latest/) to add a model registry or move the metadata store to a managed database. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere MLflow-Operationen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [MLflow-Dokumentation](https://mlflow.org/docs/latest/), um eine Model Registry hinzuzufügen oder den Metadatenspeicher auf eine verwaltete Datenbank zu verlagern. diff --git a/content/de/developer/integration/ai/ray.md b/content/de/developer/integration/ai/ray.md index e9f71b94c..6edc902dd 100644 --- a/content/de/developer/integration/ai/ray.md +++ b/content/de/developer/integration/ai/ray.md @@ -1,13 +1,13 @@ --- title: "Ray" -description: "Use Ray Data with RustFS as S3-compatible storage for dataset writes and reads." +description: "Verwenden Sie Ray Data mit RustFS als S3-kompatiblem Speicher für das Schreiben und Lesen von Datensätzen." --- -This guide connects [Ray](https://github.com/ray-project/ray) — the distributed AI and Python compute framework — to **RustFS** through Ray Data's S3 filesystem support. You will run a Ray job inside the official image, write a dataset as Parquet to a RustFS bucket, read it back, and verify the objects. The workflow was verified with `rayproject/ray:2.44.0-py311` (Ray 2.44, pyarrow filesystem) and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Ray](https://github.com/ray-project/ray) — das verteilte KI- und Python-Compute-Framework — über die S3-Dateisystemunterstützung von Ray Data mit **RustFS**. Sie führen einen Ray-Job im offiziellen Image aus, schreiben einen Datensatz als Parquet in einen RustFS-Bucket, lesen ihn zurück und prüfen die Objekte. Der Ablauf wurde mit `rayproject/ray:2.44.0-py311` (Ray 2.44, pyarrow-Dateisystem) und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR DS -->|"Parquet files"| RustFS["RustFS :9000"] ``` -Ray Data reads and writes datasets through pyarrow's `S3FileSystem`. Passing an `S3FileSystem` configured for RustFS redirects every dataset operation — Parquet, CSV, JSON — to the bucket. +Ray Data liest und schreibt Datensätze über das `S3FileSystem` von pyarrow. Wenn Sie ein für RustFS konfiguriertes `S3FileSystem` übergeben, gehen alle Datensatzoperationen — Parquet, CSV und JSON — an den Bucket. -## 1. Create the job file +## 1. Job-Datei anlegen -Create the script, replacing all connection placeholders: +Erstellen Sie das Skript und ersetzen Sie alle Verbindungsplatzhalter: ```python title="ray_s3.py" import ray @@ -45,11 +45,11 @@ print("sample:", back[0]) ray.shutdown() ``` -`endpoint_override` takes the full endpoint URL including the scheme. pyarrow's `S3FileSystem` uses path-style requests for custom endpoints, so no extra flag is needed. The same filesystem object works for `write_csv`, `read_json`, and the other Ray Data methods. +`endpoint_override` erwartet die vollständige Endpunkt-URL einschließlich des Schemas. Das `S3FileSystem` von pyarrow verwendet für eigene Endpunkte Anfragen mit pfadbasierter Adressierung (Path-Style), daher ist kein zusätzliches Flag nötig. Dasselbe Dateisystem-Objekt funktioniert für `write_csv`, `read_json` und die übrigen Methoden von Ray Data. -## 2. Run the job +## 2. Job ausführen -Run the script in the Ray image on the same Docker network as RustFS: +Führen Sie das Skript im Ray-Image im selben Docker-Netzwerk wie RustFS aus: ```bash docker run --rm --network oo-rustfs_default \ @@ -57,47 +57,48 @@ docker run --rm --network oo-rustfs_default \ rayproject/ray:2.44.0-py311 python /tmp/ray_s3.py ``` + ```text rows: 5 sample: {'id': 0, 'value': 0.0} ``` -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen -List the dataset prefix: +Listen Sie das Datensatz-Präfix auf: ```bash rc ls rustfs/my-bucket/ray-demo/ -r ``` -Ray Data wrote the dataset as a Parquet block: +Ray Data hat den Datensatz als Parquet-Block geschrieben: ```text ray-demo/events/0_000000_000000.parquet ``` -![Ray dataset files stored in the RustFS Console](./images/rustfs-ray-data.png) +![In der RustFS Console gespeicherte Ray-Datensatzdateien](./images/rustfs-ray-data.png) -## 4. Stop or reset +## 4. Anhalten oder zurücksetzen -Ray Data holds no state of its own. To delete the demo dataset: +Ray Data hält keinen eigenen Zustand. So löschen Sie den Demo-Datensatz: ```bash rc rm rustfs/my-bucket/ray-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `Unable to connect to endpoint` or timeouts +### `Unable to connect to endpoint` oder Zeitüberschreitungen -Confirm `endpoint_override` includes the scheme and is reachable from the Ray container. Inside a Compose network the hostname is `rustfs`; from the host use `http://localhost:9000`. +Stellen Sie sicher, dass `endpoint_override` das Schema enthält und vom Ray-Container aus erreichbar ist. Im Compose-Netzwerk lautet der Hostname `rustfs`; vom Host aus verwenden Sie `http://localhost:9000`. -### `Access Denied` on write +### `Access Denied` beim Schreiben -Confirm the access key and secret key are passed to `S3FileSystem` itself — Ray does not read the container's AWS environment variables through this code path. +Stellen Sie sicher, dass Zugriffsschlüssel und geheimer Zugriffsschlüssel direkt an `S3FileSystem` übergeben werden. Ray liest auf diesem Codepfad die AWS-Umgebungsvariablen des Containers nicht. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Ray operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Ray Data documentation](https://docs.ray.io/en/latest/data/data.html) to chain transformations, training ingestion, and checkpointing on the same bucket. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Ray-Operationen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Ray-Data-Dokumentation](https://docs.ray.io/en/latest/data/data.html), um Transformationen, das Einlesen für das Training und Checkpoints auf demselben Bucket zu verketten. diff --git a/content/de/developer/integration/ai/vllm.md b/content/de/developer/integration/ai/vllm.md index c471096cf..962d2b554 100644 --- a/content/de/developer/integration/ai/vllm.md +++ b/content/de/developer/integration/ai/vllm.md @@ -1,13 +1,13 @@ --- title: "vLLM" -description: "Serve LLM inference with vLLM loading model weights stored in RustFS." +description: "Stellen Sie LLM-Inferenz mit vLLM bereit, das die in RustFS gespeicherten Modellgewichte lädt." --- -This guide connects [vLLM](https://github.com/vllm-project/vllm) — the high-throughput LLM inference engine — to **RustFS** as its model-weight store. You will upload a model into a RustFS bucket, expose the bucket to the vLLM host through an rclone mount, and serve the model with the OpenAI-compatible API. The workflow was verified with `vllm/vllm-openai-cpu` (vLLM 0.30.0) serving `facebook/opt-125m` from a RustFS bucket backed by `rustfs/rustfs-x86-musl:v2.3.1`, on a CPU-only host. +In dieser Anleitung verbinden Sie [vLLM](https://github.com/vllm-project/vllm) — die LLM-Inferenz-Engine mit hohem Durchsatz — mit **RustFS** als Speicher für die Modellgewichte. Sie laden ein Modell in einen RustFS-Bucket hoch, binden den Bucket auf dem vLLM-Host über ein rclone-Mount ein und stellen das Modell über die OpenAI-kompatible API bereit. Der Ablauf wurde auf einem Nur-CPU-Host mit `vllm/vllm-openai-cpu` (vLLM 0.30.0) verifiziert, das `facebook/opt-125m` aus einem von `rustfs/rustfs-x86-musl:v2.3.1` bereitgestellten RustFS-Bucket ausliefert. -You need Docker and an rclone binary on the host that runs vLLM. This deployment is intended for local integration testing, not production. +Sie benötigen Docker und rclone auf dem Host, auf dem vLLM läuft. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -17,17 +17,17 @@ flowchart LR Client["OpenAI SDK / curl"] -->|"completions"| vLLM ``` -The bucket is the single copy of the model. Hosts that serve the model mount the bucket read-only, so every node pulls weights from RustFS and no local model store exists to drift. +Der Bucket ist die einzige Kopie des Modells. Hosts, die das Modell bereitstellen, binden den Bucket nur lesend ein. Jeder Knoten bezieht die Gewichte aus RustFS, und es gibt keinen lokalen Modellspeicher, der auseinanderlaufen kann. -:::note[Why an rclone mount] +:::note[Warum ein rclone-Mount] -vLLM 0.30 loads `s3://` model paths through the RunAI model streamer, whose ranged reads currently fail against custom S3 endpoints such as RustFS (the loader errors with `File access error` on any non-zero offset). Mounting the bucket as a filesystem is the verified way to keep the weights in RustFS while vLLM reads them as local files. +vLLM 0.30 lädt Modellpfade mit `s3://` über den RunAI Model Streamer. Dessen Lesezugriffe mit Byte-Ranges schlagen derzeit gegen eigene S3-Endpunkte wie RustFS fehl (der Loader meldet `File access error` bei jedem Offset ungleich null). Den Bucket als Dateisystem einzubinden ist der hier geprüfte Weg, die Gewichte in RustFS zu belassen, während vLLM sie als lokale Dateien liest. ::: -## 1. Upload the model to RustFS +## 1. Modell nach RustFS hochladen -Create the bucket and copy model weights into it, replacing all connection placeholders: +Legen Sie den Bucket an und kopieren Sie die Modellgewichte hinein. Ersetzen Sie alle Verbindungsplatzhalter: ```ini title="rclone.conf" [rustfs] @@ -39,16 +39,17 @@ endpoint = http://:9000 region = us-east-1 ``` + ```bash rc mb rustfs/vllm-models rclone copy ./opt-125m rustfs:vllm-models/opt-125m --transfers 4 ``` -Any Hugging Face layout works — `config.json`, the tokenizer files, and the weight files (`model.safetensors` or `pytorch_model.bin`). Keep one model per prefix so several models can share the bucket. +Jedes Hugging-Face-Layout ist geeignet: `config.json`, die Tokenizer-Dateien und die Gewichtsdateien (`model.safetensors` oder `pytorch_model.bin`). Legen Sie ein Modell pro Präfix ab, damit mehrere Modelle denselben Bucket nutzen können. -## 2. Mount the bucket on the vLLM host +## 2. Bucket auf dem vLLM-Host einbinden -On the machine that runs vLLM, mount the bucket read-only for clients with `--allow-other`: +Binden Sie den Bucket auf dem Rechner, auf dem vLLM läuft, nur lesend ein und erlauben Sie anderen Clients den Zugriff mit `--allow-other`: ```bash mkdir -p /mnt/vllm-models @@ -57,13 +58,14 @@ rclone mount rustfs:vllm-models /mnt/vllm-models \ ls /mnt/vllm-models/opt-125m/ ``` + ```text config.json merges.txt model.safetensors tokenizer.json vocab.json ``` -## 3. Run vLLM +## 3. vLLM ausführen -Start the CPU image against the mounted weights: +Starten Sie das CPU-Image gegen die eingehängten Gewichte: ```bash docker run -d --name vllm -p 8000:8000 --shm-size=2g \ @@ -73,21 +75,22 @@ docker run -d --name vllm -p 8000:8000 --shm-size=2g \ --dtype float32 --max-model-len 256 --gpu-memory-utilization 0.15 ``` -vLLM reads the weights through the mount — the container stays stateless and the model lives in RustFS. Wait for the server to come up: +vLLM liest die Gewichte über das Mount. Der Container bleibt zustandslos, und das Modell liegt in RustFS. Warten Sie, bis der Server bereit ist: ```bash curl -s http://localhost:8000/v1/models | head -c 200 ``` + ```text {"object":"list","data":[{"id":"opt-125m","object":"model","created":...,"root":"/models/opt-125m",...}]} ``` -`--gpu-memory-utilization` controls the fraction of RAM reserved for the KV cache on the CPU backend; lower it on small hosts. `--dtype float32` matches what the CPU attention kernels support for this model. +`--gpu-memory-utilization` steuert den Anteil des Arbeitsspeichers, der auf dem CPU-Backend für den KV-Cache reserviert wird. Setzen Sie den Wert auf kleinen Hosts herunter. `--dtype float32` entspricht dem, was die CPU-Attention-Kernel für dieses Modell unterstützen. -## 4. Run inference +## 4. Inferenz ausführen -Send an OpenAI-compatible completion request: +Senden Sie eine OpenAI-kompatible Completion-Anfrage: ```bash curl -s http://localhost:8000/v1/completions \ @@ -95,13 +98,14 @@ curl -s http://localhost:8000/v1/completions \ -d '{"model": "opt-125m", "prompt": "RustFS is", "max_tokens": 12, "temperature": 0}' ``` + ```json {"id":"cmpl-...","object":"text_completion","model":"opt-125m", "choices":[{"index":0,"text":" a great tool for building your own server. It's a", "finish_reason":"length",...}]} ``` -The request is standard OpenAI schema, so the Python client works unchanged: +Die Anfrage entspricht dem OpenAI-Schema, daher funktioniert der Python-Client unverändert: ```python from openai import OpenAI @@ -112,43 +116,43 @@ print(client.completions.create( ).choices[0].text) ``` -![vLLM model weights stored in the RustFS Console](./images/rustfs-vllm-models.png) +![In der RustFS Console gespeicherte vLLM-Modellgewichte](./images/rustfs-vllm-models.png) -## 5. Stop or reset +## 5. Anhalten oder zurücksetzen -To tear down the demo while keeping the bucket objects: +So bauen Sie die Demo ab und behalten die Objekte im Bucket: ```bash docker rm -f vllm fusermount -u /mnt/vllm-models ``` -To delete the stored model: +So löschen Sie das gespeicherte Modell: ```bash rclone purge rustfs:vllm-models ``` -## Troubleshooting +## Fehlerbehebung ### `Cannot find any model weights with /models/...` -The mount had a stale directory cache or the weight files never made it to the bucket. Re-run `rclone copy` and confirm the files through the mount with `ls` before starting vLLM. A short `--dir-cache-time` (for example `10s`) helps while you iterate. +Der Mount hatte einen veralteten Verzeichnis-Cache, oder die Gewichtsdateien sind nie im Bucket angekommen. Führen Sie `rclone copy` erneut aus und prüfen Sie die Dateien über das Mount mit `ls`, bevor Sie vLLM starten. Ein kurzes `--dir-cache-time` (zum Beispiel `10s`) hilft, solange Sie die Einrichtung anpassen. ### `Unsupported CPU attention configuration: head_dim=...` -vLLM's CPU kernels support a fixed set of head dimensions. Tiny test models such as `hf-internal-testing/tiny-random-*` use exotic shapes that fail at request time — use a real small model such as `facebook/opt-125m`. +Die CPU-Kernel von vLLM unterstützen nur eine feste Auswahl an Head-Dimensionen. Sehr kleine Testmodelle wie `hf-internal-testing/tiny-random-*` verwenden ungewöhnliche Formen, die erst zur Anfragezeit fehlschlagen. Verwenden Sie ein echtes kleines Modell wie `facebook/opt-125m`. ### `Insufficient space in /dev/shm` -vLLM's CPU engine exchanges tensors through shared memory. Run the container with `--shm-size=2g` (or `--ipc=host`). +Die CPU-Engine von vLLM tauscht Tensoren über Shared Memory aus. Starten Sie den Container mit `--shm-size=2g` (oder `--ipc=host`). -### Server exits with `Available memory on node 0 ... is less than desired CPU memory utilization` +### Der Server bricht mit `Available memory on node 0 ... is less than desired CPU memory utilization` ab -The default KV-cache reservation is 90% of system RAM. Lower it with `--gpu-memory-utilization 0.15` (the flag applies to the CPU backend as a memory fraction despite its name). +Die Standardreservierung für den KV-Cache beträgt 90 Prozent des Arbeitsspeichers. Senken Sie sie mit `--gpu-memory-utilization 0.15`. Das Flag gilt auf dem CPU-Backend trotz seines Namens als Anteil am Arbeitsspeicher. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional serving setups. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [vLLM documentation](https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html) for chat templates, tensor parallelism, and quantized weights on top of the same bucket-backed model store. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Inferenz-Bereitstellungen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [vLLM-Dokumentation](https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html) für Chat-Templates, Tensor-Parallelität und quantisierte Gewichte auf demselben Bucket als Modellspeicher. diff --git a/content/de/developer/integration/backup/kopia.md b/content/de/developer/integration/backup/kopia.md index fed21e5a3..9c3cf8bfb 100644 --- a/content/de/developer/integration/backup/kopia.md +++ b/content/de/developer/integration/backup/kopia.md @@ -1,13 +1,13 @@ --- title: "Kopia" -description: "Back up files to RustFS with Kopia's S3 repository backend." +description: "Sichern Sie Dateien mit dem S3-Repository-Backend von Kopia in RustFS." --- -This guide connects [Kopia](https://github.com/kopia/kopia) — the open-source backup and restore tool — to **RustFS** as an S3 repository. You will create a repository in a RustFS bucket, take a snapshot of a directory, restore it into an empty directory, and compare checksums. The workflow was verified with `kopia/kopia:0.18.1` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Kopia](https://github.com/kopia/kopia) — das quelloffene Werkzeug für Backup und Wiederherstellung — mit **RustFS** als S3-Repository. Sie legen ein Repository in einem RustFS-Bucket an, erstellen einen Snapshot eines Verzeichnisses, stellen ihn in einem leeren Verzeichnis wieder her und vergleichen die Prüfsummen. Der Ablauf wurde mit `kopia/kopia:0.18.1` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,11 +16,11 @@ flowchart LR Kopia -->|restore| Restore["Restored files"] ``` -Kopia stores the repository format files and deduplicated, encrypted content blocks in the bucket. Restores read the blocks back and reassemble the original files, so the checksum of every restored file must match the source. +Kopia speichert die Formatdateien des Repositorys und die deduplizierten, verschlüsselten Inhaltsblöcke im Bucket. Die Wiederherstellung liest die Blöcke zurück und setzt die ursprünglichen Dateien wieder zusammen. Die Prüfsumme jeder wiederhergestellten Datei muss mit der Quelle übereinstimmen. -## 1. Create the repository +## 1. Repository anlegen -Create the bucket first, then initialize the Kopia repository inside it. The endpoint is a bare `host:port` (no scheme); `--disable-tls` switches the client to plain HTTP: +Legen Sie zuerst den Bucket an und initialisieren Sie anschließend das Kopia-Repository darin. Der Endpunkt ist ein reiner Wert `host:port` ohne Schema. `--disable-tls` schaltet den Client auf unverschlüsseltes HTTP um: ```bash rc alias set rustfs http://:9000 @@ -37,11 +37,11 @@ docker run --rm --network oo-rustfs_default kopia/kopia:0.18.1 repository create --override-username demo --override-hostname workstation ``` -Kopia validates the provider by reading and writing through the S3 API before it reports success. +Kopia prüft den Anbieter, indem es über die S3-API liest und schreibt, bevor es Erfolg meldet. -## 2. Connect, snapshot, and restore +## 2. Verbinden, Snapshot erstellen und wiederherstellen -Run the following commands from the directory holding your `repository.config` (created by the previous step). Kopia reads the connection settings from that file, so the S3 flags are only needed once: +Führen Sie die folgenden Befehle aus dem Verzeichnis aus, das Ihre `repository.config` enthält (angelegt im vorherigen Schritt). Kopia liest die Verbindungseinstellungen aus dieser Datei, die S3-Flags sind daher nur einmal nötig: ```bash export KOPIA_PASSWORD= @@ -65,7 +65,7 @@ kopia snapshot create /source kopia snapshot list ``` -Restore the snapshot into an empty directory and compare checksums with the source. The snapshot ID is the `ka...` identifier printed by `snapshot list`: +Stellen Sie den Snapshot in einem leeren Verzeichnis wieder her und vergleichen Sie die Prüfsummen mit der Quelle. Die Snapshot-ID ist die Kennung `ka...`, die `snapshot list` ausgibt: ```bash kopia restore /restore @@ -73,20 +73,21 @@ kopia restore /restore sha256sum source/blob.bin restore/blob.bin ``` + ```text bec4530e2798465b... source/blob.bin bec4530e2798465b... restore/blob.bin ``` -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/kopia-backups/ -r ``` -The output shows the repository format files plus the packed content blocks written by the snapshot: +Die Ausgabe zeigt die Formatdateien des Repositorys und die gepackten Inhaltsblöcke, die der Snapshot geschrieben hat: ```text kopia.blobcfg @@ -94,32 +95,32 @@ kopia.repository p0000.../... ``` -![Kopia repository blocks stored in the RustFS Console](./images/rustfs-kopia-repo.png) +![In der RustFS Console gespeicherte Kopia-Repository-Blöcke](./images/rustfs-kopia-repo.png) -## 4. Stop or reset +## 4. Anhalten oder zurücksetzen -Kopia is a client-side tool and holds no running state. To delete the repository and all snapshots, remove the bucket: +Kopia ist ein clientseitiges Werkzeug und hält keinen laufenden Zustand. Um das Repository und alle Snapshots zu löschen, entfernen Sie den Bucket: ```bash rc rb rustfs/kopia-backups --force ``` -## Troubleshooting +## Fehlerbehebung ### `Endpoint url cannot have fully qualified paths` -The endpoint must be a bare `host:port` value without a scheme or path — Kopia builds the object URLs itself. +Der Endpunkt muss ein reiner Wert `host:port` ohne Schema oder Pfad sein. Kopia baut die Objekt-URLs selbst. ### `server gave HTTP response to HTTPS client` -Without `--disable-tls`, Kopia speaks HTTPS. RustFS without TLS needs the `--disable-tls` flag on both `repository create s3` and `repository connect s3`. +Ohne `--disable-tls` spricht Kopia HTTPS. RustFS ohne TLS benötigt das Flag `--disable-tls` sowohl bei `repository create s3` als auch bei `repository connect s3`. -### `can't connect to storage` with a DNS error +### `can't connect to storage` mit einem DNS-Fehler -The S3 client is using virtual-hosted addressing. Keep the endpoint as a bare `host:port` value; Kopia uses path-style requests for endpoints given in that form. +Der S3-Client verwendet Adressierung im Virtual-Hosted-Stil. Belassen Sie den Endpunkt als reinen Wert `host:port`. Kopia verwendet für Endpunkte in dieser Form Anfragen mit pfadbasierter Adressierung (Path-Style). -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Kopia operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Kopia repository documentation](https://kopia.io/docs/repositories/) to add policies, retention, and scheduled snapshots. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Kopia-Operationen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Kopia-Repository-Dokumentation](https://kopia.io/docs/repositories/), um Richtlinien, Aufbewahrung und geplante Snapshots hinzuzufügen. diff --git a/content/de/developer/integration/backup/longhorn.md b/content/de/developer/integration/backup/longhorn.md index 497f43cdb..a92edabd7 100644 --- a/content/de/developer/integration/backup/longhorn.md +++ b/content/de/developer/integration/backup/longhorn.md @@ -1,13 +1,13 @@ --- title: "Longhorn" -description: "Configure Longhorn to store Kubernetes volume backups in RustFS through its S3 backup target." +description: "Konfigurieren Sie Longhorn so, dass Kubernetes-Volume-Backups über das S3-Backup-Ziel in RustFS gespeichert werden." --- -This guide connects [Longhorn](https://github.com/longhorn/longhorn) — the distributed block storage system for Kubernetes — to **RustFS** as its S3 backup target. You will configure the backup target, back up a volume that contains data, delete the volume, restore it from RustFS, and verify the data. The workflow was verified with Longhorn 1.9.0 on k3s (Kubernetes 1.30) and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Longhorn](https://github.com/longhorn/longhorn) — das verteilte Blockspeichersystem für Kubernetes — mit **RustFS** als S3-Backup-Ziel. Sie konfigurieren das Backup-Ziel, sichern ein Volume mit Daten, löschen das Volume, stellen es aus RustFS wieder her und prüfen die Daten. Der Ablauf wurde mit Longhorn 1.9.0 auf k3s (Kubernetes 1.30) und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need a Kubernetes cluster with Longhorn installed and `kubectl` access to it. This guide is intended for integration testing, not production. +Sie benötigen einen Kubernetes-Cluster mit installiertem Longhorn und `kubectl`-Zugriff darauf. Diese Anleitung ist für Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,22 +16,22 @@ flowchart LR Backup -->|"blocks + config"| RustFS["RustFS :9000"] ``` -Longhorn stores backups in the `backupstore/volumes/` prefix of the target bucket as content-addressed blocks plus a small volume configuration file. Restores read those objects back into a new volume on any node that can reach RustFS. +Longhorn speichert Backups im Präfix `backupstore/volumes/` des Ziel-Buckets als inhaltsadressierte Blöcke plus eine kleine Volume-Konfigurationsdatei. Die Wiederherstellung liest diese Objekte in ein neues Volume auf jedem Knoten zurück, der RustFS erreichen kann. -## 1. Create the backup bucket +## 1. Backup-Bucket anlegen -Create a dedicated bucket with the [`rc` client](https://github.com/rustfs/cli), using your own endpoint and credentials: +Legen Sie mit dem [`rc`-Client](https://github.com/rustfs/cli) einen eigenen Bucket an. Verwenden Sie Ihren eigenen Endpunkt und Ihre eigenen Zugangsdaten: ```bash rc alias set rustfs http://:9000 rc mb rustfs/longhorn-backups ``` -Longhorn does not create the bucket, so this step must complete before the first backup. +Longhorn legt den Bucket nicht an. Dieser Schritt muss abgeschlossen sein, bevor das erste Backup startet. -## 2. Configure the backup target +## 2. Backup-Ziel konfigurieren -Store the RustFS credentials in a secret in the `longhorn-system` namespace. `AWS_ENDPOINTS` must be an endpoint every node can reach — use the node IP or an internal load balancer address, not a port forward from your workstation: +Speichern Sie die RustFS-Zugangsdaten in einem Secret im Namespace `longhorn-system`. `AWS_ENDPOINTS` muss ein Endpunkt sein, den jeder Knoten erreichen kann. Verwenden Sie die Knoten-IP oder die Adresse eines internen Load Balancers, nicht eine Portweiterleitung von Ihrer Arbeitsstation: ```bash kubectl -n longhorn-system create secret generic rustfs-s3-secret \ @@ -40,7 +40,7 @@ kubectl -n longhorn-system create secret generic rustfs-s3-secret \ --from-literal=AWS_ENDPOINTS=http://:9000 ``` -Longhorn 1.9 manages backup targets through the `BackupTarget` resource. Patch the `default` target with the RustFS bucket: +Longhorn 1.9 verwaltet Backup-Ziele über die Ressource `BackupTarget`. Patchen Sie das Ziel `default` mit dem RustFS-Bucket: ```bash kubectl -n longhorn-system patch backupTarget default --type merge -p ' @@ -50,22 +50,23 @@ spec: pollInterval: 5m' ``` -The `@us-east-1` segment is the region annotation in the S3 URL format; it does not need to match a real deployment region. +Der Abschnitt `@us-east-1` ist die Regionsangabe im S3-URL-Format. Er muss nicht zu einer echten Bereitstellungsregion passen. -Wait for the target to become available — it confirms that Longhorn reached the bucket through the secret: +Warten Sie, bis das Ziel verfügbar ist. Damit ist bestätigt, dass Longhorn den Bucket über das Secret erreicht hat: ```bash kubectl -n longhorn-system get backupTarget default ``` + ```text NAME URL CREDENTIAL AVAILABLE LASTSYNCEDAT default s3://longhorn-backups@us-east-1/ rustfs-s3-secret true 2026-09-21T08:36:55Z ``` -## 3. Write data and create a backup +## 3. Daten schreiben und ein Backup erstellen -Create a test volume with data in it. The following manifest creates a 1 GiB PVC and a pod that writes a marker file: +Legen Sie ein Test-Volume mit Daten an. Das folgende Manifest erzeugt eine PVC mit 1 GiB und einen Pod, der eine Marker-Datei schreibt: ```yaml title="demo.yaml" apiVersion: v1 @@ -97,14 +98,14 @@ spec: mountPath: /data ``` -Apply it and wait for the pod to run: +Wenden Sie es an und warten Sie, bis der Pod läuft: ```bash kubectl apply -f demo.yaml kubectl get pod demo-app ``` -Create a snapshot and back it up. You can do this in the Longhorn UI (Volume → Snapshot → Backup) or declaratively: +Erstellen Sie einen Snapshot und sichern Sie ihn. Das geht in der Longhorn-Oberfläche (**Volume → Snapshot → Backup**) oder deklarativ: ```bash VOLUME=$(kubectl get pvc demo-vol -o jsonpath='{.spec.volumeName}') @@ -119,7 +120,7 @@ spec: EOF ``` -Then create the `Backup` resource for that snapshot: +Legen Sie anschließend die Ressource `Backup` für diesen Snapshot an: ```bash kubectl -n longhorn-system apply -f - < --type merge -p ' @@ -276,18 +277,18 @@ spec: ### `failed to create backup ... missing input parameter` -The backup ran before the default backup target was configured. Complete step 2, confirm `AVAILABLE` is `true`, and create the backup again. +Das Backup lief, bevor das Standard-Backup-Ziel konfiguriert war. Schließen Sie Schritt 2 ab, stellen Sie sicher, dass `AVAILABLE` den Wert `true` hat, und erstellen Sie das Backup erneut. -### The backup target never becomes available +### Das Backup-Ziel wird nie verfügbar -The secret must exist before the target syncs, and `AWS_ENDPOINTS` must be reachable from the nodes themselves. Check the `longhorn-manager` logs for S3 errors: +Das Secret muss existieren, bevor das Ziel synchronisiert, und `AWS_ENDPOINTS` muss von den Knoten selbst erreichbar sein. Prüfen Sie die Logs von `longhorn-manager` auf S3-Fehler: ```bash kubectl -n longhorn-system logs -l app=longhorn-manager | grep -i s3 | tail ``` -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional backup targets. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Longhorn backup documentation](https://longhorn.io/docs/1.9.0/backups-and-restore/) to configure recurring backup jobs and scheduled snapshots. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Backup-Ziele verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Longhorn-Backup-Dokumentation](https://longhorn.io/docs/1.9.0/backups-and-restore/), um wiederkehrende Backup-Jobs und geplante Snapshots zu konfigurieren. diff --git a/content/de/developer/integration/backup/velero.md b/content/de/developer/integration/backup/velero.md index 0140296bf..7a5154fdc 100644 --- a/content/de/developer/integration/backup/velero.md +++ b/content/de/developer/integration/backup/velero.md @@ -1,13 +1,13 @@ --- title: "Velero" -description: "Back up Kubernetes cluster resources to RustFS with Velero's AWS object store provider." +description: "Sichern Sie Kubernetes-Cluster-Ressourcen mit dem AWS-Objektspeicher-Provider von Velero in RustFS." --- -This guide connects [Velero](https://github.com/vmware-tanzu/velero) — the Kubernetes backup and restore tool — to **RustFS** as its object storage backend. You will install Velero into a Kubernetes cluster with a RustFS backup location, back up cluster resources, delete them, restore from the bucket, and verify the restored objects. The workflow was verified with Velero CLI 1.16.2, `velero-plugin-for-aws:v1.12.2` on k3s (Kubernetes 1.30), and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Velero](https://github.com/vmware-tanzu/velero) — das Werkzeug für Backup und Wiederherstellung in Kubernetes — mit **RustFS** als Objektspeicher-Backend. Sie installieren Velero in einem Kubernetes-Cluster mit einem RustFS-Backup-Speicherort, sichern Cluster-Ressourcen, löschen sie, stellen sie aus dem Bucket wieder her und prüfen die wiederhergestellten Objekte. Der Ablauf wurde mit Velero CLI 1.16.2, `velero-plugin-for-aws:v1.12.2` auf k3s (Kubernetes 1.30) und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need a Kubernetes cluster with `kubectl` access and the Velero CLI. This guide is intended for integration testing, not production. +Sie benötigen einen Kubernetes-Cluster mit `kubectl`-Zugriff und die Velero-CLI. Diese Anleitung ist für Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,20 +15,20 @@ flowchart LR V -->|"backups + logs"| RustFS["RustFS :9000"] ``` -Velero serializes Kubernetes resources and (optionally) pod volume data into gzip archives under `backups//` in the bucket. Restores download those archives and recreate the resources in the cluster. +Velero serialisiert Kubernetes-Ressourcen und optional Pod-Volume-Daten in gzip-Archive unter `backups//` im Bucket. Die Wiederherstellung lädt diese Archive herunter und legt die Ressourcen im Cluster neu an. -## 1. Create the backup bucket +## 1. Backup-Bucket anlegen -Create a dedicated bucket — Velero does not create buckets: +Legen Sie einen eigenen Bucket an. Velero legt keine Buckets an: ```bash rc alias set rustfs http://:9000 rc mb rustfs/velero-backups ``` -## 2. Install Velero +## 2. Velero installieren -Write the credentials to a file and install the Velero server. The `s3Url` must be an endpoint reachable from the cluster pods themselves — use the node IP or an internal address, not a port forward from your workstation: +Schreiben Sie die Zugangsdaten in eine Datei und installieren Sie den Velero-Server. Die `s3Url` muss ein Endpunkt sein, den die Cluster-Pods selbst erreichen können. Verwenden Sie die Knoten-IP oder eine interne Adresse, nicht eine Portweiterleitung von Ihrer Arbeitsstation: ```bash cat > velero-creds <|"poll key"| RustFS ``` -Every S3 interaction inside a DAG goes through the provider's S3 client, pointed at RustFS by the connection's `endpoint_url`. Operators, sensors, and hooks share the same connection object. +Jede S3-Interaktion innerhalb eines DAG läuft über den S3-Client des Providers, den die `endpoint_url` der Verbindung auf RustFS ausrichtet. Operatoren, Sensoren und Hooks verwenden dasselbe Verbindungsobjekt. -## 1. Run Airflow +## 1. Airflow starten -Start a standalone instance with examples disabled, and create the demo bucket: +Starten Sie eine Standalone-Instanz mit deaktivierten Beispielen und legen Sie den Demo-Bucket an: ```bash docker run -d --name airflow --network oo-rustfs_default -p 8080:8080 \ @@ -31,11 +31,11 @@ docker run -d --name airflow --network oo-rustfs_default -p 8080:8080 \ rc mb rustfs/airflow-demo ``` -The image ships with all providers preinstalled, including `apache-airflow-providers-amazon`. +Das Image enthält alle Provider vorinstalliert, einschließlich `apache-airflow-providers-amazon`. -## 2. Register the RustFS connection +## 2. Die RustFS-Verbindung registrieren -The S3 provider reads its endpoint from the connection's extra field. Replace all connection placeholders: +Der S3-Provider liest seinen Endpunkt aus dem Extra-Feld der Verbindung. Ersetzen Sie alle Platzhalter der Verbindung: ```bash docker exec airflow airflow connections add rustfs \ @@ -43,11 +43,11 @@ docker exec airflow airflow connections add rustfs \ --conn-extra '{"endpoint_url": "http://:9000", "region_name": "us-east-1", "aws_access_key_id": "", "aws_secret_access_key": ""}' ``` -The keys `aws_access_key_id` and `aws_secret_access_key` inside `--conn-extra` supply credentials; `endpoint_url` redirects the boto3 client from AWS to RustFS. +Die Schlüssel `aws_access_key_id` und `aws_secret_access_key` in `--conn-extra` liefern die Zugangsdaten. `endpoint_url` lenkt den boto3-Client von AWS auf RustFS um. -## 3. Write the DAG +## 3. Den DAG schreiben -The DAG writes an object with an operator, waits for the key with a sensor, and reads it back with the hook: +Der DAG schreibt ein Objekt mit einem Operator, wartet mit einem Sensor auf den Objektschlüssel und liest es mit dem Hook zurück: ```python title="rustfs_demo.py" import datetime @@ -95,18 +95,18 @@ def rustfs_demo(): rustfs_demo() ``` -Note the import paths: `S3CreateObjectOperator` lives in the `operators` module while `S3KeySensor` lives in the `sensors` module — importing both from one place fails. +Beachten Sie die Importpfade: `S3CreateObjectOperator` liegt im Modul `operators`, `S3KeySensor` im Modul `sensors`. Der Import beider Klassen aus derselben Stelle schlägt fehl. -## 4. Unpause and trigger +## 4. Fortsetzen und auslösen -New DAGs start paused, and a trigger fired while paused stays queued forever. Unpause first, then trigger: +Neue DAGs starten pausiert, und ein Auslöser, der im pausierten Zustand feuert, bleibt dauerhaft in der Warteschlange. Heben Sie die Pause zuerst auf und lösen Sie den DAG dann aus: ```bash docker exec airflow airflow dags unpause rustfs_demo docker exec airflow airflow dags trigger rustfs_demo ``` -Watch the run finish: +Beobachten Sie, bis der Lauf abgeschlossen ist: ```bash docker exec airflow airflow dags list-runs rustfs_demo | head -3 @@ -117,11 +117,11 @@ dag_id run_id state rustfs_demo manual__2026-09-29T13:15:57.332688+00:00 success ``` -All three tasks succeed: `write_object`, `wait_for_object`, and `read_object`. +Alle drei Tasks sind erfolgreich: `write_object`, `wait_for_object` und `read_object`. -## 5. Verify objects in RustFS +## 5. Objekte in RustFS prüfen -List the bucket prefix: +Listen Sie das Bucket-Präfix auf: ```bash rc ls rustfs/airflow-demo/ -r @@ -133,38 +133,38 @@ rc cat rustfs/airflow-demo/dags/airflow-put.txt written by airflow to rustfs ``` -![Airflow object stored in the RustFS Console](./images/rustfs-airflow-object.png) +![In der RustFS-Console gespeichertes Airflow-Objekt](./images/rustfs-airflow-object.png) -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen -To tear down the demo while keeping the bucket objects: +Um die Demo abzubauen und die Bucket-Objekte zu behalten: ```bash docker rm -f airflow ``` -To delete the stored data: +Um die gespeicherten Daten zu löschen: ```bash rc rm rustfs/airflow-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### Dag runs stay `queued` after triggering +### DAG-Läufe bleiben nach dem Auslösen im Status `queued` -The DAG is paused. New DAGs are paused by default in Airflow 3, and runs triggered in that state never execute. Run `airflow dags unpause rustfs_demo`; queued runs then start on their own. +Der DAG ist pausiert. Neue DAGs sind in Airflow 3 standardmäßig pausiert, und Läufe, die in diesem Zustand ausgelöst werden, werden nie ausgeführt. Führen Sie `airflow dags unpause rustfs_demo` aus. Läufe in der Warteschlange starten danach von selbst. ### `cannot import name 'S3KeySensor' from 'airflow.providers.amazon.aws.operators.s3'` -The sensor lives in a separate module: `from airflow.providers.amazon.aws.sensors.s3 import S3KeySensor`. +Der Sensor liegt in einem eigenen Modul: `from airflow.providers.amazon.aws.sensors.s3 import S3KeySensor`. -### Tasks fail with connection errors +### Tasks schlagen mit Verbindungsfehlern fehl -The `endpoint_url` must be reachable from the Airflow container — use the Docker network hostname for RustFS, not `localhost`. Airflow 3 serves its health endpoint under `/api/v2/monitor/health` if you need to check component status. +Die `endpoint_url` muss vom Airflow-Container aus erreichbar sein. Verwenden Sie den Docker-Netzwerk-Hostnamen von RustFS, nicht `localhost`. Airflow 3 stellt den Endpunkt für die Integritätsprüfung unter `/api/v2/monitor/health` bereit, wenn Sie den Komponentenstatus prüfen möchten. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional provider hooks. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Amazon provider documentation](https://airflow.apache.org/docs/apache-airflow-providers-amazon/stable/index.html) for transfer operators such as `S3ToLocalFilesystemOperator` and `LocalFilesystemToS3Operator`. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Provider-Hooks einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Dokumentation des Amazon-Providers](https://airflow.apache.org/docs/apache-airflow-providers-amazon/stable/index.html) für Transfer-Operatoren wie `S3ToLocalFilesystemOperator` und `LocalFilesystemToS3Operator`. diff --git a/content/de/developer/integration/big-data/automq.md b/content/de/developer/integration/big-data/automq.md index 053a28dee..e333c0cd5 100644 --- a/content/de/developer/integration/big-data/automq.md +++ b/content/de/developer/integration/big-data/automq.md @@ -1,13 +1,13 @@ --- title: "AutoMQ" -description: "Run AutoMQ with RustFS as the S3-backed log storage." +description: "Betreiben Sie AutoMQ mit RustFS als S3-gestütztem Log-Speicher." --- -This guide connects [AutoMQ](https://github.com/AutoMQ/automq) — the cloud-native Kafka distribution that keeps its log storage in object storage — to **RustFS**. You will start a single-node AutoMQ broker in KRaft mode with its S3 log buckets pointed at RustFS, then produce and consume messages. The workflow was verified with AutoMQ 1.3.0 (Kafka 3.9.0 API) against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [AutoMQ](https://github.com/AutoMQ/automq) — die cloud-native Kafka-Distribution, die ihren Log-Speicher im Objektspeicher hält — mit **RustFS**. Sie starten einen AutoMQ-Broker mit einem Knoten im KRaft-Modus, dessen S3-Log-Buckets auf RustFS zeigen, und produzieren und konsumieren anschließend Nachrichten. Der Ablauf wurde mit AutoMQ 1.3.0 (Kafka-API 3.9.0) gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -17,11 +17,11 @@ flowchart LR Consumer["Console consumer"] -->|"fetch"| Broker ``` -AutoMQ decouples storage from brokers: the write-ahead log is buffered locally, then uploaded as immutable stream objects into the bucket. The broker keeps no local data directory beyond the WAL. +AutoMQ trennt den Speicher von den Brokern: das Write-Ahead-Log wird lokal gepuffert und danach als unveränderliche Stream-Objekte in den Bucket hochgeladen. Der Broker behält über das WAL hinaus kein lokales Datenverzeichnis. -## 1. Run the broker +## 1. Den Broker starten -Start AutoMQ with the S3 buckets pointed at RustFS. Four details are mandatory: space-separated script arguments (`--key=value` makes the startup script loop forever), `JAVA_TOOL_OPTIONS` with `-XX:-UseContainerSupport` (the bundled JDK 17 crashes on cgroup v2 detection otherwise), the `server` combined role, and credentials via `KAFKA_S3_ACCESS_KEY`/`KAFKA_S3_SECRET_KEY` environment variables (the `--s3.access.key` script arguments are ignored): +Starten Sie AutoMQ so, dass die S3-Buckets auf RustFS zeigen. Vier Angaben sind zwingend: durch Leerzeichen getrennte Skriptargumente (die Form `--key=value` lässt das Startskript endlos laufen), `JAVA_TOOL_OPTIONS` mit `-XX:-UseContainerSupport` (das mitgelieferte JDK 17 stürzt sonst bei der Erkennung von cgroup v2 ab), die kombinierte Rolle `server` und Zugangsdaten über die Umgebungsvariablen `KAFKA_S3_ACCESS_KEY` und `KAFKA_S3_SECRET_KEY` (die Skriptargumente `--s3.access.key` werden ignoriert): ```bash docker run -d --name automq --hostname automq --network oo-rustfs_default -p 9092:9092 \ @@ -39,9 +39,9 @@ docker run -d --name automq --hostname automq --network oo-rustfs_default -p 909 --s3.endpoint http://rustfs:9000 ``` -The broker binds its listener to the container IP. For the console tools, address it by that IP (the hostname `automq` also works from inside the container). +Der Broker bindet seinen Listener an die Container-IP. Sprechen Sie ihn für die Kafka-Konsolenwerkzeuge über diese IP an. Der Hostname `automq` funktioniert ebenfalls von innerhalb des Containers. -## 2. Create a topic and produce +## 2. Ein Topic anlegen und produzieren ```bash AIP= @@ -53,7 +53,7 @@ docker exec automq sh -c "cd /opt/automq/kafka && \ ./bin/kafka-console-producer.sh --bootstrap-server $AIP:9092 --topic rustfs-automq" ``` -## 3. Consume the messages +## 3. Die Nachrichten konsumieren ```bash docker exec automq sh -c "cd /opt/automq/kafka && \ @@ -68,9 +68,9 @@ mq-msg-three Processed a total of 3 messages ``` -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen -List the bucket — AutoMQ writes its log streams and metrics as objects: +Listen Sie den Bucket auf. AutoMQ schreibt seine Log-Streams und Metriken als Objekte: ```bash rc ls rustfs/automq-demo/ -r @@ -82,41 +82,41 @@ automq/logs/rZdE0DjZSrqy96PXrMUZVw/0/2026100701/52877dc7-... automq/metrics/rZdE0DjZSrqy96PXrMUZVw/0/2026100701/4733e680-... ``` -The log stream objects hold the topic data — the broker keeps only the WAL locally, so scaling brokers up or down does not move data. +Die Objekte der Log-Streams enthalten die Topic-Daten. Der Broker behält lokal nur das WAL, daher verschiebt das Hoch- oder Herunterskalieren von Brokern keine Daten. -![AutoMQ log streams stored in the RustFS Console](./images/rustfs-automq-logs.png) +![AutoMQ-Log-Streams in der RustFS-Console](./images/rustfs-automq-logs.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen ```bash docker rm -f automq rc rm rustfs/automq-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### Startup script prints `setup_value:` lines forever at 100% CPU +### Das Startskript gibt endlos Zeilen `setup_value:` bei voller CPU-Last aus -The argument parser only accepts the space-separated form (`--s3.bucket x`, not `--s3.bucket=x`). The `=` form makes the parser loop forever. +Der Argumentparser akzeptiert nur die durch Leerzeichen getrennte Form (`--s3.bucket x`, nicht `--s3.bucket=x`). Die Form mit `=` lässt den Parser endlos laufen. ### `java.lang.NullPointerException ... CgroupInfo.getMountPoint()` -The bundled JDK 17 fails cgroup v2 detection in this image. Set `JAVA_TOOL_OPTIONS="-XX:-UseContainerSupport"`. +Das mitgelieferte JDK 17 scheitert in diesem Image an der Erkennung von cgroup v2. Setzen Sie `JAVA_TOOL_OPTIONS="-XX:-UseContainerSupport"`. ### `unknown process role broker,controller` -AutoMQ 1.3.0's script expects the combined role to be spelled `server`. +Das Skript von AutoMQ 1.3.0 erwartet, dass die kombinierte Rolle `server` heißt. -### Broker starts but clients get `Connection to node -1 could not be established` +### Der Broker startet, Clients erhalten aber `Connection to node -1 could not be established` -The listener binds to the container IP (`hostname -I`). Address the broker by that IP or by the hostname `automq` from inside the same Docker network — `localhost` only works for tools running inside the broker container itself. +Der Listener bindet sich an die Container-IP (`hostname -I`). Sprechen Sie den Broker über diese IP oder über den Hostnamen `automq` aus demselben Docker-Netzwerk an. `localhost` funktioniert nur für Werkzeuge, die im Broker-Container selbst laufen. ### `List objects failed, cost: 120000+ ms` -AutoMQ uses virtual-host addressing by default and falls into a retry loop against IP endpoints. Force path-style buckets by overriding the bucket URLs with `KAFKA_CFG_S3_DATA_BUCKETS`/`KAFKA_CFG_S3_OPS_BUCKETS` set to `0@s3://?region=us-east-1&endpoint=http://rustfs:9000&pathStyle=true&authType=static`, and pass credentials via `KAFKA_S3_ACCESS_KEY`/`KAFKA_S3_SECRET_KEY`. +AutoMQ verwendet standardmäßig Adressierung im Virtual-Hosted-Stil und gerät gegenüber IP-Endpunkten in eine Wiederholungsschleife. Erzwingen Sie Buckets mit pfadbasierter Adressierung (Path-Style), indem Sie die Bucket-URLs über `KAFKA_CFG_S3_DATA_BUCKETS` und `KAFKA_CFG_S3_OPS_BUCKETS` auf `0@s3://?region=us-east-1&endpoint=http://rustfs:9000&pathStyle=true&authType=static` setzen, und übergeben Sie die Zugangsdaten über `KAFKA_S3_ACCESS_KEY` und `KAFKA_S3_SECRET_KEY`. -## Next steps +## Nächste Schritte -- Compare with the [Kafka](/developer/integration/big-data/kafka) guide when you prefer connect-based S3 integration on stock Kafka. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [AutoMQ documentation](https://docs.automq.com/) for multi-node clusters and WAL parameter tuning on the same bucket. +- Vergleichen Sie die Anleitung mit [Kafka](/de/developer/integration/big-data/kafka), wenn Sie die S3-Anbindung über Connect auf unverändertem Kafka bevorzugen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [AutoMQ-Dokumentation](https://docs.automq.com/) für Cluster mit mehreren Knoten und die Abstimmung der WAL-Parameter auf demselben Bucket. diff --git a/content/de/developer/integration/big-data/delta-lake.md b/content/de/developer/integration/big-data/delta-lake.md index b1bfae566..52892b0db 100644 --- a/content/de/developer/integration/big-data/delta-lake.md +++ b/content/de/developer/integration/big-data/delta-lake.md @@ -1,13 +1,13 @@ --- title: "Delta Lake" -description: "Write and read Delta tables on RustFS with delta-rs." +description: "Schreiben und lesen Sie Delta-Tabellen auf RustFS mit delta-rs." --- -This guide connects [Delta Lake](https://github.com/delta-io/delta) — the open-source lakehouse table format — to **RustFS** through delta-rs, the Rust-native Delta implementation. You will write a Delta table to a RustFS bucket from Python, read it back with ACID transaction history, and confirm the `_delta_log` and Parquet files in the bucket. The workflow was verified with the `deltalake` Python package (delta-rs) and pandas against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Delta Lake](https://github.com/delta-io/delta) — das quelloffene Lakehouse-Tabellenformat — über delta-rs, die Rust-native Delta-Implementierung, mit **RustFS**. Sie schreiben aus Python eine Delta-Tabelle in einen RustFS-Bucket, lesen sie mit der ACID-Transaktionshistorie zurück und prüfen die Dateien `_delta_log` und Parquet im Bucket. Der Ablauf wurde mit dem Python-Paket `deltalake` (delta-rs) und pandas gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Python 3.9 or newer. This deployment is intended for local integration testing, not production. +Sie benötigen Python 3.9 oder neuer. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,19 +16,19 @@ flowchart LR Query["DeltaTable"] -->|"read / time travel"| RustFS ``` -delta-rs stores each table as Parquet files plus a transaction log (`_delta_log/`). All I/O goes through the `object_store` crate, configured with the same AWS environment variables as other S3 clients. +delta-rs speichert jede Tabelle als Parquet-Dateien plus ein Transaktionsprotokoll (`_delta_log/`). Die gesamte Ein- und Ausgabe läuft über die Crate `object_store`, konfiguriert mit denselben AWS-Umgebungsvariablen wie andere S3-Clients. -## 1. Install the client +## 1. Den Client installieren ```bash pip install deltalake pandas pyarrow ``` -`pyarrow` is required to convert pandas frames into Delta-compatible record batches. +`pyarrow` wird benötigt, um pandas-Frames in Delta-kompatible Record-Batches umzuwandeln. -## 2. Write a Delta table +## 2. Eine Delta-Tabelle schreiben -Create the bucket and write a table, replacing all connection placeholders. `AWS_S3_ALLOW_UNSAFE_RENAME` is needed because RustFS does not provide copy-if-not-exists, which delta-rs otherwise uses for commit conflicts: +Legen Sie den Bucket an und schreiben Sie eine Tabelle. Ersetzen Sie alle Verbindungsplatzhalter. `AWS_S3_ALLOW_UNSAFE_RENAME` ist erforderlich, weil RustFS kein copy-if-not-exists bereitstellt, das delta-rs sonst für Commit-Konflikte verwendet: ```python title="delta_s3.py" import pandas as pd @@ -53,9 +53,9 @@ print("written:", df.shape[0], "rows") written: 3 rows ``` -The `table` URI uses the standard `s3://bucket/prefix` form; the endpoint and credentials come from `storage_options`. +Die URI `table` verwendet die übliche Form `s3://bucket/prefix`. Endpunkt und Zugangsdaten kommen aus `storage_options`. -## 3. Read the table back +## 3. Die Tabelle zurücklesen ```python title="delta_read.py" from deltalake import DeltaTable @@ -75,51 +75,51 @@ read back: 3 rows version: 0 ``` -Because the version is tracked in the transaction log, the same table supports time travel with `DeltaTable(..., version=N)` and appends that bump the version. +Weil die Version im Transaktionsprotokoll geführt wird, unterstützt dieselbe Tabelle Time Travel mit `DeltaTable(..., version=N)` und Anhänge, die die Version erhöhen. -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen -List the table prefix: +Listen Sie das Tabellenpräfix auf: ```bash rc ls rustfs// -r ``` -The first commit created the transaction log and one Parquet file: +Der erste Commit hat das Transaktionsprotokoll und eine Parquet-Datei angelegt: ```text events/_delta_log/00000000000000000000.json events/part-00000-3859855e-45e4-4ae5-94ff-2d8eab5e7ebb-c000.snappy.parquet ``` -Every new write adds a `NNNNNNNNNNNNNNNNNNNN.json` log entry and Parquet parts; readers replay the log to get a consistent snapshot. +Jeder weitere Schreibvorgang fügt einen Protokolleintrag `NNNNNNNNNNNNNNNNNNNN.json` und Parquet-Teile hinzu. Leser spielen das Protokoll ab, um einen konsistenten Snapshot zu erhalten. -![Delta table files stored in the RustFS Console](./images/rustfs-delta-table.png) +![In der RustFS-Console gespeicherte Delta-Tabellendateien](./images/rustfs-delta-table.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -delta-rs holds no state of its own. To delete the table: +delta-rs hält keinen eigenen Zustand. So löschen Sie die Tabelle: ```bash rc rm rustfs//events/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `Import pyarrow failed` when writing a pandas DataFrame +### `Import pyarrow failed` beim Schreiben eines pandas-DataFrame -`write_deltalake` converts frames through Arrow. Install `pyarrow` alongside `deltalake` and `pandas`. +`write_deltalake` wandelt Frames über Arrow um. Installieren Sie `pyarrow` zusammen mit `deltalake` und `pandas`. -### `Generic DeltaTable error: commit conflict` or rename errors on commit +### `Generic DeltaTable error: commit conflict` oder Umbenennungsfehler beim Commit -delta-rs commits by copying and renaming temporary objects, which requires atomic rename on the backend. For S3-compatible stores without copy-if-not-exists, set `AWS_S3_ALLOW_UNSAFE_RENAME: "true"` in `storage_options` — acceptable for a single writer, not for concurrent writers. +delta-rs committet, indem es temporäre Objekte kopiert und umbenennt. Dafür ist ein atomares Umbenennen auf dem Backend nötig. Setzen Sie bei S3-kompatiblen Speichern ohne copy-if-not-exists in `storage_options` den Wert `AWS_S3_ALLOW_UNSAFE_RENAME: "true"`. Das ist für einen einzelnen Schreiber akzeptabel, für gleichzeitige Schreiber nicht. ### `Unknown lengthy error: AWS connectivity or endpoint errors` -Confirm `AWS_ENDPOINT_URL` includes the scheme and that `AWS_ALLOW_HTTP` is `"true"` for plain-HTTP endpoints; without it the S3 client only speaks HTTPS. +Prüfen Sie, dass `AWS_ENDPOINT_URL` das Schema enthält und dass `AWS_ALLOW_HTTP` für Endpunkte mit unverschlüsseltem HTTP auf `"true"` steht. Ohne diesen Wert spricht der S3-Client nur HTTPS. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Delta clients. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [delta-rs usage documentation](https://delta-io.github.io/delta-rs/usage/writing/writing-to-s3/) for concurrent-writer setups with DynamoDB-backed commit coordination. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Delta-Clients einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [delta-rs-Dokumentation zum Schreiben](https://delta-io.github.io/delta-rs/usage/writing/writing-to-s3/) für Konfigurationen mit gleichzeitigen Schreibern und einer Commit-Koordination auf DynamoDB-Basis. diff --git a/content/de/developer/integration/big-data/dolphinscheduler.md b/content/de/developer/integration/big-data/dolphinscheduler.md index ca90bc0aa..703fc6ca5 100644 --- a/content/de/developer/integration/big-data/dolphinscheduler.md +++ b/content/de/developer/integration/big-data/dolphinscheduler.md @@ -1,13 +1,13 @@ --- title: "DolphinScheduler" -description: "Store DolphinScheduler resources on RustFS over S3." +description: "Speichern Sie DolphinScheduler-Ressourcen über S3 auf RustFS." --- -This guide connects [Apache DolphinScheduler](https://github.com/apache/dolphinscheduler) — the workflow scheduler — to **RustFS** as its resource center storage. You will run the standalone server, switch the resource storage to S3, upload a resource file through the API, and verify the object in the bucket. The workflow was verified with DolphinScheduler 3.2.1 (standalone server) against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache DolphinScheduler](https://github.com/apache/dolphinscheduler) — den Workflow-Scheduler — mit **RustFS** als Speicher für das Resource Center. Sie betreiben den Standalone-Server, stellen den Ressourcenspeicher auf S3 um, laden eine Ressourcendatei über die API hoch und prüfen das Objekt im Bucket. Der Ablauf wurde mit DolphinScheduler 3.2.1 (Standalone-Server) gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. +Sie benötigen Docker. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,9 +15,9 @@ flowchart LR DS -->|"S3 API"| RustFS["RustFS :9000"] ``` -The resource center stores workflow scripts, dependency JARs, and other files. With S3 storage every uploaded file becomes an object under `dolphinscheduler//resources/` in the bucket. +Das Resource Center speichert Workflow-Skripte, Abhängigkeits-JARs und weitere Dateien. Bei S3-Speicher wird jede hochgeladene Datei zu einem Objekt unter `dolphinscheduler//resources/` im Bucket. -## 1. Run the standalone server +## 1. Den Standalone-Server starten ```bash docker run -d --name dolphinscheduler --hostname dolphinscheduler \ @@ -25,11 +25,11 @@ docker run -d --name dolphinscheduler --hostname dolphinscheduler \ apache/dolphinscheduler-standalone-server:3.2.1 ``` -The single container bundles master, worker, API, alert, and an embedded ZooKeeper. The UI is at `http://localhost:12345/dolphinscheduler/ui` (default login `admin` / `dolphinscheduler123`). +Der einzelne Container bündelt Master, Worker, API, Alert und ein eingebettetes ZooKeeper. Die Oberfläche liegt unter `http://localhost:12345/dolphinscheduler/ui` (Standardanmeldung `admin` / `dolphinscheduler123`). -## 2. Switch the resource center to RustFS +## 2. Das Resource Center auf RustFS umstellen -The storage backend lives in `/opt/dolphinscheduler/conf/common.properties`. Append the S3 properties to the existing file — do not replace the file, it holds many other settings: +Das Speicher-Backend liegt in `/opt/dolphinscheduler/conf/common.properties`. Hängen Sie die S3-Properties an die vorhandene Datei an. Ersetzen Sie die Datei nicht, sie enthält viele weitere Einstellungen: ```bash docker exec dolphinscheduler bash -c "cat >> /opt/dolphinscheduler/conf/common.properties << 'EOF' @@ -45,15 +45,15 @@ EOF" docker restart dolphinscheduler ``` -Wait for the API to come back (about a minute), then create the bucket: +Warten Sie, bis die API wieder verfügbar ist (etwa eine Minute), und legen Sie dann den Bucket an: ```bash rc mb rustfs/ds-demo ``` -## 3. Upload a resource file +## 3. Eine Ressourcendatei hochladen -Log in through the API to get a session id, then upload a file. The endpoint requires both `name` and `fullName` parameters: +Melden Sie sich über die API an, um eine Sitzungs-ID zu erhalten, und laden Sie dann eine Datei hoch. Der Endpunkt verlangt sowohl den Parameter `name` als auch `fullName`: ```bash printf "ds resource file stored in rustfs" > /tmp/ds-file.txt @@ -71,9 +71,9 @@ curl -s -m 30 -X POST "http://localhost:12345/dolphinscheduler/resources" \ {"code":0,"msg":"success","data":null,"failed":false,"success":true} ``` -## 4. Verify in DolphinScheduler and RustFS +## 4. In DolphinScheduler und RustFS prüfen -Read the file back through the API: +Lesen Sie die Datei über die API zurück: ```bash curl -s -m 30 "http://localhost:12345/dolphinscheduler/resources/view-ui?fullName=/ds-file.txt&skipLineNum=100&limit=100" \ @@ -84,7 +84,7 @@ curl -s -m 30 "http://localhost:12345/dolphinscheduler/resources/view-ui?fullNam ds resource file stored in rustfs ``` -List the bucket — the file sits under the tenant's resources prefix: +Listen Sie den Bucket auf. Die Datei liegt unter dem Ressourcenpräfix des Tenants: ```bash rc ls rustfs/ds-demo/ -r @@ -95,31 +95,31 @@ dolphinscheduler/default/resources/ds-file.txt dolphinscheduler/default/udfs/ ``` -![DolphinScheduler resources stored in the RustFS Console](./images/rustfs-ds-resources.png) +![In der RustFS-Console gespeicherte DolphinScheduler-Ressourcen](./images/rustfs-ds-resources.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen ```bash docker rm -f dolphinscheduler rc rm rustfs/ds-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### Server fails to start with an Azure `clientId/tenantId/clientSecret` error +### Der Server startet mit einem Azure-Fehler zu `clientId/tenantId/clientSecret` nicht -The storage config was written as a brand-new file instead of appended, so `resource.storage.type=S3` was lost and the defaults pointed at Azure. Always append to the existing `common.properties` as in step 2. +Die Speicherkonfiguration wurde als neue Datei geschrieben statt angehängt, dadurch ging `resource.storage.type=S3` verloren und die Standardwerte zeigten auf Azure. Hängen Sie die Einstellungen immer an die vorhandene `common.properties` an, wie in Schritt 2. ### `Required request parameter 'name'/'fullName' is not present` -The resource create endpoint requires both `name` and `fullName` form fields alongside `file`, `type`, and `currentDir`. +Der Endpunkt zum Anlegen von Ressourcen verlangt die Formularfelder `name` und `fullName` zusätzlich zu `file`, `type` und `currentDir`. -### API returns 405 for the token call +### Die API antwortet mit 405 auf den Token-Aufruf -The login/token endpoints accept POST but `/api/v2/token` style endpoints differ per version — use the login form shown in step 3 and pass `session-id` header plus `Cookie: sessionId=...` on every call. +Die Login- und Token-Endpunkte akzeptieren POST. Endpunkte im Stil von `/api/v2/token` unterscheiden sich je nach Version. Verwenden Sie das Login-Formular aus Schritt 3 und übergeben Sie bei jedem Aufruf den Header `session-id` sowie `Cookie: sessionId=...`. -## Next steps +## Nächste Schritte -- Compare with the [Airflow](/developer/integration/big-data/airflow) guide for orchestration without a built-in resource center. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [DolphinScheduler documentation](https://dolphinscheduler.apache.org/en-us/docs/latest/user_doc/common/resource-management.html) to wire the same S3 resource center into worker task execution. +- Vergleichen Sie die Anleitung mit [Airflow](/de/developer/integration/big-data/airflow) für Orchestrierung ohne eingebautes Resource Center. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [DolphinScheduler-Dokumentation](https://dolphinscheduler.apache.org/en-us/docs/latest/user_doc/common/resource-management.html), um dasselbe S3-Resource-Center in die Ausführung von Worker-Tasks einzubinden. diff --git a/content/de/developer/integration/big-data/flink.md b/content/de/developer/integration/big-data/flink.md index eb2cceda0..db6222368 100644 --- a/content/de/developer/integration/big-data/flink.md +++ b/content/de/developer/integration/big-data/flink.md @@ -233,13 +233,13 @@ docker compose run --rm --entrypoint /bin/sh create-bucket -c \ [2026-09-21 01:34:52] 41 B flink-out/part-f759f9e8-3d1b-46a1-a92e-53e9b727e831-task-0-file-0 ``` -Sie können das Präfix auch in der RustFS-Konsole anzeigen: +Sie können das Präfix auch in der RustFS Console anzeigen: -![Die in der RustFS-Konsole gespeicherte Flink-Ausgabedatei](./images/rustfs-flink-objects.png) +![Die in der RustFS Console gespeicherte Flink-Ausgabedatei](./images/rustfs-flink-objects.png) ## 6. RustFS S3 Tables verwenden -RustFS S3 Tables bietet einen integrierten Apache-Iceberg-REST-Katalog, sodass Flink einen Tabellen-Bucket als verwaltetes Iceberg-Warehouse nutzen kann, während die Daten in RustFS bleiben. Aktivieren Sie einen Tabellen-Bucket und richten Sie den REST-Katalog des Flink-Iceberg-Connectors auf RustFS, wie in [S3 Tables](/administration/data/s3-tables) beschrieben: Die REST-Katalog-URI ist `http://:9000/iceberg`, das Warehouse ist der Bucket-Name, und sowohl Kataloganfragen (AWS Signature Version 4, Signing-Name `s3`) als auch der S3-Dateizugriff verwenden pfadbasierte Adressierung (Path-Style). +RustFS S3 Tables bietet einen integrierten Apache-Iceberg-REST-Katalog, sodass Flink einen Tabellen-Bucket als verwaltetes Iceberg-Warehouse nutzen kann, während die Daten in RustFS bleiben. Aktivieren Sie einen Tabellen-Bucket und richten Sie den REST-Katalog des Flink-Iceberg-Connectors auf RustFS, wie in [S3 Tables](/de/administration/data/s3-tables) beschrieben: Die REST-Katalog-URI ist `http://:9000/iceberg`, das Warehouse ist der Bucket-Name, und sowohl Kataloganfragen (AWS Signature Version 4, Signing-Name `s3`) als auch der S3-Dateizugriff verwenden pfadbasierte Adressierung (Path-Style). Laut der S3-Tables-Support-Matrix validieren Sie die exakten Flink- und Iceberg-Versionen Ihrer Bereitstellung gegen den Katalog, bevor Sie diesen Pfad in Produktion übernehmen. @@ -273,6 +273,6 @@ Die Wiederherstellung eines laufenden S3-Uploads nach einem Fehler kann den Writ ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [Apache-Flink-Dokumentation](https://nightlies.apache.org/flink/flink-docs-stable/) für Filesystem-Connector-Optionen wie Partitionierung und Kompaktierung. diff --git a/content/de/developer/integration/big-data/hive.md b/content/de/developer/integration/big-data/hive.md index e1d506726..98f41c5d6 100644 --- a/content/de/developer/integration/big-data/hive.md +++ b/content/de/developer/integration/big-data/hive.md @@ -1,13 +1,13 @@ --- title: "Hive" -description: "Store Hive table data on RustFS over S3A." +description: "Speichern Sie Hive-Tabellendaten über S3A auf RustFS." --- -This guide connects [Apache Hive](https://github.com/apache/hive) — the classic data warehouse — to **RustFS** through the S3A filesystem. You will run the Hive 4.0.1 Docker image with a metastore and HiveServer2, configure S3A in three configuration layers, create an external table over a RustFS location, and load and query data. The workflow was verified with Hive 4.0.1 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache Hive](https://github.com/apache/hive) — das klassische Data Warehouse — über das Dateisystem S3A mit **RustFS**. Sie betreiben das Docker-Image von Hive 4.0.1 mit einem Metastore und HiveServer2, konfigurieren S3A in drei Konfigurationsschichten, legen eine externe Tabelle über einem RustFS-Speicherort an und laden Daten und fragen sie ab. Der Ablauf wurde mit Hive 4.0.1 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker (two containers: metastore and hiveserver2). +Sie benötigen Docker (zwei Container: Metastore und HiveServer2). -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,9 +16,9 @@ flowchart LR HS2 -->|"Tez tasks: S3A"| RustFS["RustFS :9000"] ``` -Hive stores table metadata in the metastore (Derby in this test) and table data in the table's S3A location. Query execution runs on Tez inside the hiveserver2 container. +Hive speichert Tabellenmetadaten im Metastore (in diesem Test Derby) und Tabellendaten am S3A-Speicherort der Tabelle. Die Abfrageausführung läuft auf Tez im Container hiveserver2. -## 1. Run the metastore and HiveServer2 +## 1. Metastore und HiveServer2 starten ```bash docker run -d --name hive-metastore --hostname hive-meta --network oo-rustfs_default \ @@ -28,11 +28,11 @@ docker run -d --name hive-server --hostname hive-server --network oo-rustfs_defa -e SERVICE_NAME=hiveserver2 -e DB_DRIVER=derby apache/hive:4.0.1 ``` -The metastore takes 1-2 minutes to initialize its Derby schema; HiveServer2 listens on 10000, the metastore on 9083. +Der Metastore braucht 1–2 Minuten, um sein Derby-Schema zu initialisieren. HiveServer2 lauscht auf 10000, der Metastore auf 9083. -## 2. Configure S3A in three places +## 2. S3A an drei Stellen konfigurieren -Tez tasks read the Hadoop configuration directory, HiveServer2 reads the Hive configuration, and the metastore needs the endpoint too. Create one properties file and copy it to all three paths: +Tez-Tasks lesen das Hadoop-Konfigurationsverzeichnis, HiveServer2 liest die Hive-Konfiguration, und der Metastore braucht den Endpunkt ebenfalls. Legen Sie eine Properties-Datei an und kopieren Sie sie an alle drei Pfade: ```xml title="s3a-core-site.xml" @@ -61,9 +61,9 @@ docker exec hive-server bash -c \ docker restart hive-server ``` -The `hadoop-aws` jar ships in `/opt/hadoop/share/hadoop/tools/lib` — the `HADOOP_CLASSPATH` export puts it on the query classpath. `mkdir /home/hive/.beeline` silences a harmless beeline home-directory error. +Das JAR `hadoop-aws` liegt in `/opt/hadoop/share/hadoop/tools/lib`. Der Export `HADOOP_CLASSPATH` setzt es auf den Abfrage-Classpath. `mkdir /home/hive/.beeline` unterdrückt einen harmlosen Fehler zum Home-Verzeichnis von Beeline. -## 3. Create an external table +## 3. Eine externe Tabelle anlegen ```bash docker exec hive-server bash -c "cd /opt/hive && beeline -u 'jdbc:hive2://localhost:10000' \ @@ -72,11 +72,11 @@ docker exec hive-server bash -c "cd /opt/hive && beeline -u 'jdbc:hive2://localh LOCATION 's3a://hive-demo/warehouse/events';\"" ``` -An `EXTERNAL` table with an S3A `LOCATION` keeps all data in RustFS. (A managed `CREATE TABLE ... LOCATION` on a non-default database path is rejected by Hive 4 managed-table rules — use external tables for S3A locations.) +Eine Tabelle `EXTERNAL` mit einer S3A-`LOCATION` hält alle Daten in RustFS. Ein verwaltetes `CREATE TABLE ... LOCATION` auf einem Pfad außerhalb der Standarddatenbank lehnt Hive 4 nach den Regeln für verwaltete Tabellen ab. Verwenden Sie für S3A-Speicherorte externe Tabellen. -## 4. Load and query data +## 4. Daten laden und abfragen -`LOAD DATA INPATH` moves a local file into the table's S3A location (the rename is executed by HiveServer2, which has the credentials): +`LOAD DATA INPATH` verschiebt eine lokale Datei an den S3A-Speicherort der Tabelle. Das Umbenennen führt HiveServer2 aus, das die Zugangsdaten besitzt: ```bash docker exec hive-server bash -c "printf '1,alpha\n2,beta\n3,gamma\n' > /tmp/hive-load.txt" @@ -88,7 +88,7 @@ docker exec hive-server bash -c "cd /opt/hive && beeline -u 'jdbc:hive2://localh INFO : Loading data to table default.events from file:/tmp/hive-load.txt ``` -## 5. Query and verify in RustFS +## 5. Abfragen und in RustFS prüfen ```bash docker exec hive-server bash -c "cd /opt/hive && beeline -u 'jdbc:hive2://localhost:10000' \ @@ -101,7 +101,7 @@ docker exec hive-server bash -c "cd /opt/hive && beeline -u 'jdbc:hive2://localh 3 gamma ``` -List the table directory — the loaded file is an ordinary object: +Listen Sie das Tabellenverzeichnis auf. Die geladene Datei ist ein gewöhnliches Objekt: ```bash rc ls rustfs/hive-demo/warehouse/events/ @@ -113,35 +113,35 @@ warehouse/events/hive-load_copy_1.txt warehouse/events/hive-load_copy_2.txt ``` -![Hive warehouse files stored in the RustFS Console](./images/rustfs-hive-warehouse.png) +![In der RustFS-Console gespeicherte Dateien des Hive-Warehouses](./images/rustfs-hive-warehouse.png) -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen ```bash docker rm -f hive-server hive-metastore rc rm rustfs/hive-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `NoClassDefFoundError: org.apache.tez.mapreduce.hadoop.InputSplitInfo` on INSERT +### `NoClassDefFoundError: org.apache.tez.mapreduce.hadoop.InputSplitInfo` bei INSERT -The Tez jars are missing from the query classpath. Add the `HADOOP_CLASSPATH` export from step 2 (tools lib + tez + tez lib) to `/opt/hive/conf/hive-env.sh`. +Die Tez-JARs fehlen auf dem Abfrage-Classpath. Fügen Sie den Export `HADOOP_CLASSPATH` aus Schritt 2 (tools lib, tez und tez lib) in `/opt/hive/conf/hive-env.sh` ein. ### `NoAwsCredentialsException: SimpleAWSCredentialsProvider: No AWS credentials in the Hadoop configuration` -Tez task processes read `/opt/hadoop/etc/hadoop/core-site.xml`, not only the Hive conf directory. Copy the S3A properties to all three paths from step 2. +Tez-Task-Prozesse lesen `/opt/hadoop/etc/hadoop/core-site.xml`, nicht nur das Hive-Konfigurationsverzeichnis. Kopieren Sie die S3A-Properties an alle drei Pfade aus Schritt 2. -### `Permission denied` printed after every beeline command +### Nach jedem Beeline-Befehl erscheint `Permission denied` -beeline tries to create `/home/hive/.beeline`. Run `mkdir -p /home/hive/.beeline && chmod 777` once (as root in the container). +Beeline versucht, `/home/hive/.beeline` anzulegen. Führen Sie einmal `mkdir -p /home/hive/.beeline && chmod 777` aus (als root im Container). ### `Unable to create database managed path file:/user/hive/warehouse/...` -Hive 4 keeps managed databases inside the managed warehouse root. Use `CREATE EXTERNAL TABLE ... LOCATION 's3a://...'` for S3A locations. +Hive 4 hält verwaltete Datenbanken im Wurzelverzeichnis des verwalteten Warehouses. Verwenden Sie `CREATE EXTERNAL TABLE ... LOCATION 's3a://...'` für S3A-Speicherorte. -## Next steps +## Nächste Schritte -- Compare with the [Trino](/developer/integration/database/trino) guide when you want interactive SQL over the same objects without a metastore. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Hive documentation](https://hive.apache.org/) to attach a MySQL-backed metastore and share the same warehouse across Hive and Spark on the same bucket. +- Vergleichen Sie die Anleitung mit [Trino](/de/developer/integration/database/trino), wenn Sie interaktives SQL über dieselben Objekte ohne Metastore möchten. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Hive-Dokumentation](https://hive.apache.org/), um einen Metastore auf MySQL-Basis anzubinden und dasselbe Warehouse zwischen Hive und Spark auf demselben Bucket zu teilen. diff --git a/content/de/developer/integration/big-data/hudi.md b/content/de/developer/integration/big-data/hudi.md index 42026454b..33a0ef251 100644 --- a/content/de/developer/integration/big-data/hudi.md +++ b/content/de/developer/integration/big-data/hudi.md @@ -1,24 +1,24 @@ --- title: "Apache Hudi" -description: "Write Apache Hudi tables to RustFS through Spark and the s3a connector." +description: "Schreiben Sie Apache-Hudi-Tabellen über Spark und den Connector s3a nach RustFS." --- -This guide connects [Apache Hudi](https://github.com/apache/hudi) — the transactional data lake platform — to **RustFS** as its copy-on-write table store. You will run Spark with the Hudi bundle, write a table to the `s3a://` location inside a RustFS bucket, read it back, and verify the table files. The workflow was verified with `apache/spark:3.5.6`, `hudi-spark3.5-bundle_2.12:0.15.0`, `hadoop-aws:3.3.4`, and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache Hudi](https://github.com/apache/hudi) — die transaktionale Data-Lake-Plattform — mit **RustFS** als Copy-on-Write-Tabellenspeicher. Sie betreiben Spark mit dem Hudi-Bundle, schreiben eine Tabelle an den Speicherort `s3a://` in einem RustFS-Bucket, lesen sie zurück und prüfen die Tabellendateien. Der Ablauf wurde mit `apache/spark:3.5.6`, `hudi-spark3.5-bundle_2.12:0.15.0`, `hadoop-aws:3.3.4` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR Job["Spark + Hudi"] -->|"commit + parquet"| RustFS["RustFS :9000"] ``` -Hudi stores the `.hoodie/` timeline, commit files, and Parquet data blocks under the table path in the bucket. Reads resolve the latest table snapshot from the timeline, so every write and query goes through the S3 API. +Hudi speichert die Timeline `.hoodie/`, Commit-Dateien und Parquet-Datenblöcke unter dem Tabellenpfad im Bucket. Lesevorgänge lösen den aktuellen Tabellen-Snapshot aus der Timeline auf, daher läuft jeder Schreib- und Abfragevorgang über die S3-API. -## 1. Run the Spark write +## 1. Den Spark-Schreibvorgang ausführen -Hudi requires the Kryo serializer and the s3a credentials as Hadoop properties. The following `spark-shell` session creates a non-partitioned table in `my-bucket` — replace all connection placeholders: +Hudi verlangt den Kryo-Serializer und die s3a-Zugangsdaten als Hadoop-Properties. Die folgende `spark-shell`-Sitzung legt eine nicht partitionierte Tabelle in `my-bucket` an. Ersetzen Sie alle Verbindungsplatzhalter: ```scala import org.apache.spark.sql.SaveMode @@ -52,7 +52,7 @@ docker run --rm --network oo-rustfs_default \ -i /tmp/hudi_test.scala ``` -The `--packages` flags download the Hudi bundle and the s3a connector on first run. The `spark.jars.ivy` setting avoids Ivy cache permission errors in the container. The read-back `show()` prints the three rows: +Die Flags `--packages` laden das Hudi-Bundle und den Connector s3a beim ersten Lauf herunter. Die Einstellung `spark.jars.ivy` vermeidet Berechtigungsfehler des Ivy-Cache im Container. Das zurückgelesene `show()` gibt die drei Zeilen aus: ```text +---+----+ @@ -62,15 +62,15 @@ The `--packages` flags download the Hudi bundle and the s3a connector on first r +---+----+ ``` -## 2. Verify objects in RustFS +## 2. Objekte in RustFS prüfen -List the table prefix: +Listen Sie das Tabellenpräfix auf: ```bash rc ls rustfs/my-bucket/hudi-demo/ -r ``` -The Hudi table layout appears under the table path — the `.hoodie/` timeline with the commit file, plus the Parquet data block: +Das Hudi-Tabellenlayout erscheint unter dem Tabellenpfad: die Timeline `.hoodie/` mit der Commit-Datei sowie der Parquet-Datenblock: ```text hudi-demo/events/.hoodie/20260922015803291.commit @@ -78,32 +78,32 @@ hudi-demo/events/.hoodie/20260922015803291.commit.requested hudi-demo/events/// ``` -![Hudi table files stored in the RustFS Console](./images/rustfs-hudi-table.png) +![In der RustFS-Console gespeicherte Hudi-Tabellendateien](./images/rustfs-hudi-table.png) -## 3. Stop or reset +## 3. Stoppen oder zurücksetzen -Spark runs as a one-shot client and holds no state. To delete the demo table: +Spark läuft als einmaliger Client und hält keinen Zustand. So löschen Sie die Demo-Tabelle: ```bash rc rm rustfs/my-bucket/hudi-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `hoodie only support org.apache.spark.serializer.KryoSerializer as spark.serializer` -Hudi rejects the default Spark serializer. Pass `--conf spark.serializer=org.apache.spark.serializer.KryoSerializer` as shown above. +Hudi lehnt den Standard-Serializer von Spark ab. Übergeben Sie `--conf spark.serializer=org.apache.spark.serializer.KryoSerializer` wie oben gezeigt. -### `Partition-path field has to be non-empty` or keygenerator class errors +### `Partition-path field has to be non-empty` oder Fehler der Keygenerator-Klasse -For a non-partitioned table, keep the default key generator (do not set `hoodie.datasource.write.keygenerator.class`) and set `hoodie.datasource.write.partitionpath.field` to the empty string. +Belassen Sie für eine nicht partitionierte Tabelle den Standard-Key-Generator und setzen Sie `hoodie.datasource.write.keygenerator.class` nicht. Setzen Sie `hoodie.datasource.write.partitionpath.field` auf die leere Zeichenkette. -### `NoSuchMethodError` or `ClassNotFoundException` in the Hudi write +### `NoSuchMethodError` oder `ClassNotFoundException` beim Hudi-Schreibvorgang -The Spark and Hudi bundle versions must match: `hudi-spark3.5-bundle_2.12` goes with Spark 3.5.x, and the bundled Hadoop client must be compatible with `hadoop-aws:3.3.4`. +Die Versionen von Spark und dem Hudi-Bundle müssen zusammenpassen: `hudi-spark3.5-bundle_2.12` gehört zu Spark 3.5.x, und der gebündelte Hadoop-Client muss mit `hadoop-aws:3.3.4` kompatibel sein. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Hudi operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Hudi Spark guide](https://hudi.apache.org/docs/quick-start-guide/) to add upserts, compaction, and query integrations on the same table. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Hudi-Operationen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie dem [Hudi-Spark-Leitfaden](https://hudi.apache.org/docs/quick-start-guide/), um Upserts, Compaction und Abfrageintegrationen auf derselben Tabelle hinzuzufügen. diff --git a/content/de/developer/integration/big-data/kafka.md b/content/de/developer/integration/big-data/kafka.md index ff1e92f9f..cdf39b9b4 100644 --- a/content/de/developer/integration/big-data/kafka.md +++ b/content/de/developer/integration/big-data/kafka.md @@ -1,15 +1,15 @@ --- title: "Kafka" -description: "Offload Kafka topic data to RustFS with the Kafka Connect S3 sink connector." +description: "Lagern Sie Kafka-Topic-Daten mit dem Kafka-Connect-S3-Sink-Connector nach RustFS aus." --- -This guide connects [Apache Kafka](https://github.com/apache/kafka) — the distributed event streaming platform — to **RustFS** through the Kafka Connect S3 sink connector. You will run a KRaft broker and a Connect worker, deploy the S3 sink for a topic, and produce records that land as objects in a RustFS bucket. The workflow was verified with `apache/kafka:4.0.0` and `confluentinc/kafka-connect-s3` v10.5.25 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache Kafka](https://github.com/apache/kafka) — die verteilte Event-Streaming-Plattform — über den Kafka-Connect-S3-Sink-Connector mit **RustFS**. Sie betreiben einen KRaft-Broker und einen Connect-Worker, stellen den S3-Sink für ein Topic bereit und produzieren Datensätze, die als Objekte in einem RustFS-Bucket landen. Der Ablauf wurde mit `apache/kafka:4.0.0` und `confluentinc/kafka-connect-s3` v10.5.25 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -Kafka's KIP-405 tiered storage needs a `RemoteLogStorageManager` plugin, and the S3 implementations in the ecosystem are vendor-proprietary. The Connect S3 sink is the open, self-hosted way to move topic data to S3-compatible storage and is the approach documented here. +Die gestufte Speicherung nach Kafka KIP-405 benötigt ein Plugin `RemoteLogStorageManager`, und die S3-Implementierungen im Ökosystem sind herstellerspezifisch. Der Connect-S3-Sink ist der offene, selbst gehostete Weg, Topic-Daten in S3-kompatiblen Speicher zu verschieben, und ist der hier dokumentierte Ansatz. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -18,11 +18,11 @@ flowchart LR Connect -->|"batched objects"| RustFS["RustFS :9000"] ``` -The sink task consumes a topic in a dedicated consumer group and writes record batches to the bucket, one object per `flush.size` records per partition. +Der Sink-Task konsumiert ein Topic in einer eigenen Consumer-Gruppe und schreibt Datensatzstapel in den Bucket, ein Objekt je `flush.size` Datensätze je Partition. -## 1. Run the broker +## 1. Den Broker starten -Start a KRaft broker whose advertised listener is reachable from other containers: +Starten Sie einen KRaft-Broker, dessen angekündigter Listener von anderen Containern aus erreichbar ist: ```bash docker run -d --name kafka --hostname kafka --network oo-rustfs_default \ @@ -46,20 +46,20 @@ docker exec kafka /opt/kafka/bin/kafka-topics.sh \ rc mb rustfs/kafka-demo ``` -The image defaults to advertising `localhost:9092`, which only works from inside the broker container. The `KAFKA_ADVERTISED_LISTENERS` override is what makes Connect (and any remote client) able to reach the broker. +Das Image kündigt standardmäßig `localhost:9092` an, was nur aus dem Broker-Container heraus funktioniert. Die Überschreibung `KAFKA_ADVERTISED_LISTENERS` macht den Broker für Connect und jeden entfernten Client erreichbar. -## 2. Install the connector +## 2. Den Connector installieren -Download the Confluent Hub archive, which bundles the connector and its dependencies, and unpack it where the worker can see it: +Laden Sie das Confluent-Hub-Archiv herunter, das den Connector und seine Abhängigkeiten bündelt, und entpacken Sie es dort, wo der Worker es sieht: ```bash curl -Lo kafka-connect-s3.zip "https://hub-downloads.confluent.io/api/plugins/confluentinc/kafka-connect-s3/versions/10.5.25/confluentinc-kafka-connect-s3-10.5.25.zip" unzip kafka-connect-s3.zip -d /opt/kafka-conn/plugins ``` -## 3. Configure the worker and the sink +## 3. Worker und Sink konfigurieren -Create the worker properties. The value converter must be `ByteArrayConverter` so records are written verbatim: +Legen Sie die Worker-Properties an. Der Value-Converter muss `ByteArrayConverter` sein, damit Datensätze unverändert geschrieben werden: ```ini title="worker.properties" bootstrap.servers=kafka:9092 @@ -70,7 +70,7 @@ offset.flush.interval.ms=5000 plugin.path=/opt/kafka-conn-plugins ``` -Create the sink connector configuration, replacing all connection placeholders: +Legen Sie die Konfiguration des Sink-Connectors an und ersetzen Sie alle Verbindungsplatzhalter: ```ini title="rustfs-sink.properties" name=rustfs-sink @@ -87,11 +87,11 @@ format.class=io.confluent.connect.s3.format.bytearray.ByteArrayFormat consumer.override.auto.offset.reset=earliest ``` -Kafka 4.0 moved the class to `org.apache.kafka.connect.converters.ByteArrayConverter` — the old `storage` package path no longer resolves. +Kafka 4.0 hat die Klasse nach `org.apache.kafka.connect.converters.ByteArrayConverter` verschoben. Der alte Paketpfad `storage` lässt sich nicht mehr auflösen. -## 4. Run the worker +## 4. Den Worker starten -Run `connect-standalone` in the foreground so its logs go to `docker logs`, with the bucket credentials in the environment: +Führen Sie `connect-standalone` im Vordergrund aus, damit die Logs in `docker logs` landen, und setzen Sie die Bucket-Zugangsdaten in der Umgebung: ```bash docker run -d --name kafka-connect --hostname kafka-connect \ @@ -105,22 +105,22 @@ docker run -d --name kafka-connect --hostname kafka-connect \ /opt/kafka/bin/connect-standalone.sh /etc/kafka/worker.properties /etc/kafka/sink.properties ``` -The worker is ready when the sink task claims the partition: +Der Worker ist bereit, wenn der Sink-Task die Partition beansprucht: ```text INFO [rustfs-sink|task-0] Assigned topic partitions: [rustfs-topic-0] ``` -## 5. Produce records +## 5. Datensätze produzieren -Send at least `flush.size` records so the connector completes a batch: +Senden Sie mindestens `flush.size` Datensätze, damit der Connector einen Stapel abschließt: ```bash docker exec kafka sh -c "printf 'msg-one\nmsg-two\nmsg-three\n' | \ /opt/kafka/bin/kafka-console-producer.sh --bootstrap-server localhost:9092 --topic rustfs-topic" ``` -After a few seconds the batch becomes an object in the bucket: +Nach einigen Sekunden wird der Stapel zu einem Objekt im Bucket: ```bash rc ls rustfs/kafka-demo/ -r @@ -135,44 +135,44 @@ msg-two msg-three ``` -The object name encodes topic, partition, and starting offset. Each subsequent batch of three records lands in the next object (`+0000000003.bin` and so on). +Der Objektname kodiert Topic, Partition und Start-Offset. Jeder folgende Stapel von drei Datensätzen landet im nächsten Objekt (`+0000000003.bin` und so weiter). -![Kafka sink objects stored in the RustFS Console](./images/rustfs-kafka-sink.png) +![In der RustFS-Console gespeicherte Objekte des Kafka-Sinks](./images/rustfs-kafka-sink.png) -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen -To tear down the demo while keeping the bucket objects: +Um die Demo abzubauen und die Bucket-Objekte zu behalten: ```bash docker rm -f kafka-connect kafka ``` -To delete the stored data: +Um die gespeicherten Daten zu löschen: ```bash rc rm rustfs/kafka-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `AdminClient ... Rebootstrapping with Cluster (id: null)` loops forever +### `AdminClient ... Rebootstrapping with Cluster (id: null)` läuft endlos -The broker advertises `localhost:9092`, so a remote client receives metadata pointing at itself. Set `KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://kafka:9092` (and matching listener variables) as in step 1. +Der Broker kündigt `localhost:9092` an, daher erhält ein entfernter Client Metadaten, die auf ihn selbst zeigen. Setzen Sie `KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://kafka:9092` und die passenden Listener-Variablen wie in Schritt 1. ### `Invalid schema type for ByteArrayConverter: STRING` -The `ByteArrayFormat` writer only accepts raw bytes. Either switch the worker's `value.converter` to the ByteArray converter or choose a format class that matches the converter you use. +Der Writer `ByteArrayFormat` akzeptiert nur Rohbytes. Stellen Sie entweder den `value.converter` des Workers auf den ByteArray-Converter um oder wählen Sie eine Formatklasse, die zu dem Converter passt, den Sie verwenden. ### `Class org.apache.kafka.connect.storage.ByteArrayConverter could not be found` -Kafka 4.0 moved the class to `org.apache.kafka.connect.converters.ByteArrayConverter`. Use the new package path in `worker.properties`. +Kafka 4.0 hat die Klasse nach `org.apache.kafka.connect.converters.ByteArrayConverter` verschoben. Verwenden Sie den neuen Paketpfad in `worker.properties`. -### The connector downloads but the plugin is not found +### Der Connector wird heruntergeladen, das Plugin wird aber nicht gefunden -The plain connector JAR from Maven lacks its dependencies. Use the Confluent Hub archive from step 2, which bundles the complete `lib/` directory, and make sure `plugin.path` points at the directory that contains the connector folder. +Das reine Connector-JAR von Maven enthält seine Abhängigkeiten nicht. Verwenden Sie das Confluent-Hub-Archiv aus Schritt 2, das das vollständige Verzeichnis `lib/` bündelt, und stellen Sie sicher, dass `plugin.path` auf das Verzeichnis zeigt, das den Connector-Ordner enthält. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional connectors. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Kafka Connect S3 sink documentation](https://docs.confluent.io/kafka-connect-s3/current/index.html) for Parquet and Avro formats, partitioning by time, and IAM-based credential chains. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Connectoren einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Dokumentation zum Kafka-Connect-S3-Sink](https://docs.confluent.io/kafka-connect-s3/current/index.html) für die Formate Parquet und Avro, die Partitionierung nach Zeit und Zugangsdatenketten auf IAM-Basis. diff --git a/content/de/developer/integration/big-data/meta.json b/content/de/developer/integration/big-data/meta.json index 834b14a48..cf81bd4aa 100644 --- a/content/de/developer/integration/big-data/meta.json +++ b/content/de/developer/integration/big-data/meta.json @@ -1,5 +1,5 @@ { - "title": "Big Data", + "title": "Datenanalyse", "pages": [ "airflow", "dolphinscheduler", diff --git a/content/de/developer/integration/big-data/paimon.md b/content/de/developer/integration/big-data/paimon.md index f8f542656..687e53434 100644 --- a/content/de/developer/integration/big-data/paimon.md +++ b/content/de/developer/integration/big-data/paimon.md @@ -1,13 +1,13 @@ --- title: "Paimon" -description: "Run Paimon lakehouse tables on RustFS with Spark." +description: "Betreiben Sie Paimon-Lakehouse-Tabellen auf RustFS mit Spark." --- -This guide connects [Apache Paimon](https://github.com/apache/paimon) — the streaming lakehouse table format — to **RustFS** as its warehouse storage. You will create a Paimon catalog over a RustFS bucket with Spark, write a primary-key table, and read it back. The workflow was verified with Paimon 1.2.0 on Spark 3.5.6 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache Paimon](https://github.com/apache/paimon) — das Streaming-Lakehouse-Tabellenformat — mit **RustFS** als Warehouse-Speicher. Sie legen mit Spark einen Paimon-Katalog über einem RustFS-Bucket an, schreiben eine Tabelle mit Primärschlüssel und lesen sie zurück. Der Ablauf wurde mit Paimon 1.2.0 auf Spark 3.5.6 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker and the `rc` client. +Sie benötigen Docker und den Client `rc`. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,9 +15,9 @@ flowchart LR Paimon -->|"schemas, snapshots, data files"| RustFS["RustFS :9000"] ``` -Paimon stores each table under the catalog warehouse as a `*.db` directory containing `schema/`, `snapshot/`, and data files. All I/O goes through Paimon's own S3 FileIO (`paimon-s3`), not Hadoop S3A. +Paimon speichert jede Tabelle unter dem Warehouse des Katalogs als Verzeichnis `*.db` mit `schema/`, `snapshot/` und Datendateien. Die gesamte Ein- und Ausgabe läuft über Paimons eigenes S3-FileIO (`paimon-s3`), nicht über Hadoop S3A. -## 1. Run Spark +## 1. Spark starten ```bash docker run -d --name spark-paimon --hostname spark --network oo-rustfs_default \ @@ -25,7 +25,7 @@ docker run -d --name spark-paimon --hostname spark --network oo-rustfs_default \ docker cp paimon_test.sql spark-paimon:/tmp/paimon_test.sql ``` -Create the SQL file (note: the catalog options are passed on the CLI below, not in the file): +Legen Sie die SQL-Datei an. Die Katalogoptionen werden unten auf der CLI übergeben, nicht in der Datei: ```sql title="paimon_test.sql" CREATE TABLE paimon.default.events (id INT, label STRING) TBLPROPERTIES ("primary-key"="id"); @@ -33,9 +33,9 @@ INSERT INTO paimon.default.events VALUES (1,'alpha'),(2,'beta'),(3,'gamma'); SELECT * FROM paimon.default.events ORDER BY id; ``` -## 2. Run the SQL script +## 2. Das SQL-Skript ausführen -Three pieces are required: the Spark extensions, Paimon's own S3 FileIO (`paimon-s3` — the Hadoop S3A jars are not used by Paimon's reader), and the catalog-level `s3.*` options: +Drei Bestandteile sind erforderlich: die Spark-Erweiterungen, Paimons eigenes S3-FileIO (`paimon-s3`; die Hadoop-S3A-JARs verwendet der Reader von Paimon nicht) und die `s3.*`-Optionen auf Katalogebene: ```bash docker exec -u root spark-paimon bash -c "cd /opt/spark && \ @@ -59,9 +59,9 @@ Time taken: 9.447 seconds Time taken: 1.257 seconds, Fetched 3 row(s) ``` -Without the extensions line Paimon fails fast with a `requiredSparkConfsCheck` error; without `paimon-s3` the catalog fails with `UnsupportedSchemeException: Could not find a file io implementation for scheme 's3'`. +Ohne die Zeile mit den Erweiterungen bricht Paimon sofort mit einem Fehler `requiredSparkConfsCheck` ab. Ohne `paimon-s3` scheitert der Katalog mit `UnsupportedSchemeException: Could not find a file io implementation for scheme 's3'`. -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen ```bash rc ls rustfs/paimon-demo/warehouse/ -r | head -6 @@ -74,37 +74,37 @@ warehouse/default.db/events/bucket-0/data-... warehouse/default.db/events/manifest/... ``` -The bucket holds the full lakehouse layout: schemas, snapshots, manifests, and data files per bucket. +Der Bucket enthält das vollständige Lakehouse-Layout: Schemas, Snapshots, Manifeste und Datendateien je Bucket. -![Paimon warehouse stored in the RustFS Console](./images/rustfs-paimon-warehouse.png) +![In der RustFS-Console gespeichertes Paimon-Warehouse](./images/rustfs-paimon-warehouse.png) -## 4. Stop or reset +## 4. Stoppen oder zurücksetzen ```bash docker rm -f spark-paimon rc rm rustfs/paimon-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `UnsupportedSchemeException: Could not find a file io implementation for scheme 's3'` -Paimon's own FileIO needs its S3 plugin on the classpath. Add `org.apache.paimon:paimon-s3:1.2.0` to `--packages` alongside the Spark connector. +Das eigene FileIO von Paimon braucht sein S3-Plugin auf dem Classpath. Fügen Sie `org.apache.paimon:paimon-s3:1.2.0` in `--packages` neben dem Spark-Connector hinzu. ### `When using Paimon, it is necessary to configure spark.sql.extensions...` -Add `--conf spark.sql.extensions=org.apache.paimon.spark.extensions.PaimonSparkSessionExtensions` — Paimon fails fast without it. +Fügen Sie `--conf spark.sql.extensions=org.apache.paimon.spark.extensions.PaimonSparkSessionExtensions` hinzu. Ohne diese Zeile bricht Paimon sofort ab. ### `SCHEMA_NOT_FOUND: The schema paimon cannot be found` -The catalog was not registered. Register it as `spark.sql.catalog.paimon` and qualify table names with `paimon.`. +Der Katalog wurde nicht registriert. Registrieren Sie ihn als `spark.sql.catalog.paimon` und qualifizieren Sie Tabellennamen mit `paimon.`. -### Writes fail with S3 errors on the exec side +### Schreibvorgänge schlagen auf der Executor-Seite mit S3-Fehlern fehl -The catalog-level `s3.*` options (`s3.endpoint`, `s3.access-key`, `s3.secret-key`, `s3.path-style-access`) are what Paimon's FileIO reads — Hadoop `fs.s3a.*` settings alone are not used by the exec-side file operations. +Die `s3.*`-Optionen auf Katalogebene (`s3.endpoint`, `s3.access-key`, `s3.secret-key`, `s3.path-style-access`) liest das FileIO von Paimon. Die Hadoop-Einstellungen `fs.s3a.*` allein verwendet die Dateioperation auf der Executor-Seite nicht. -## Next steps +## Nächste Schritte -- Compare with the [Iceberg](/developer/integration/big-data/iceberg), [Hudi](/developer/integration/big-data/hudi), and [Delta Lake](/developer/integration/big-data/delta-lake) guides for the other lakehouse formats on the same bucket. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Paimon documentation](https://paimon.apache.org/docs/master/) for compaction, changelog producers, and Flink streaming writes on the same bucket. +- Vergleichen Sie die Anleitungen zu [Iceberg](/de/developer/integration/big-data/iceberg), [Hudi](/de/developer/integration/big-data/hudi) und [Delta Lake](/de/developer/integration/big-data/delta-lake) für die anderen Lakehouse-Formate auf demselben Bucket. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Paimon-Dokumentation](https://paimon.apache.org/docs/master/) für Compaction, Changelog-Producer und Streaming-Schreibvorgänge mit Flink auf demselben Bucket. diff --git a/content/de/developer/integration/big-data/pyiceberg.md b/content/de/developer/integration/big-data/pyiceberg.md index 5ccd6a362..eee5a26d7 100644 --- a/content/de/developer/integration/big-data/pyiceberg.md +++ b/content/de/developer/integration/big-data/pyiceberg.md @@ -7,7 +7,7 @@ Mit **PyIceberg** erstellen Sie einen Namespace und eine Tabelle im RustFS-S3-Ta ## Voraussetzungen -- Schließen Sie die [Einrichtung von S3 Tables](/administration/data/s3-tables) ab: Erstellen und aktivieren Sie `my-bucket` und erfüllen Sie die Anforderungen an Konto und TLS. +- Schließen Sie die [Einrichtung von S3 Tables](/de/administration/data/s3-tables) ab: Erstellen und aktivieren Sie `my-bucket` und erfüllen Sie die Anforderungen an Konto und TLS. - Behalten Sie `RUSTFS_ENDPOINT`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `AWS_DEFAULT_REGION` wie dort beschrieben bei. ## 1. Client installieren @@ -159,7 +159,7 @@ Das Ergebnis sollte `("analytics", "events")` enthalten. :::note[Nur Katalogeinträge entfernen] -Die folgenden Befehle entfernen den Tabelleneintrag dieser Anleitung und den anschließend leeren Namespace. Bucket und zugrunde liegende Objekte bleiben erhalten. Planen Sie eine eventuelle Datenbereinigung vorab: Nach `drop_table` kann die Tabellenwartung die Tabelle nicht mehr finden. Siehe [Wartung und Schutz vor Datenverlust](/administration/data/s3-tables). +Die folgenden Befehle entfernen den Tabelleneintrag dieser Anleitung und den anschließend leeren Namespace. Bucket und zugrunde liegende Objekte bleiben erhalten. Planen Sie eine eventuelle Datenbereinigung vorab: Nach `drop_table` kann die Tabellenwartung die Tabelle nicht mehr finden. Siehe [Wartung und Schutz vor Datenverlust](/de/administration/data/s3-tables). ::: @@ -175,4 +175,4 @@ PY ## Nächste Schritte - Nutzen Sie die [PyIceberg-API-Dokumentation](https://py.iceberg.apache.org/api/) für Client-Operationen und gleichen Sie jede Operation mit dem RustFS-Supportumfang ab. -- Verwenden Sie die [Integration mit externem Iceberg-Katalog](/developer/integration/big-data/iceberg), wenn Sie einen separaten Katalogdienst betreiben. +- Verwenden Sie die [Integration mit externem Iceberg-Katalog](/de/developer/integration/big-data/iceberg), wenn Sie einen separaten Katalogdienst betreiben. diff --git a/content/de/developer/integration/big-data/seatunnel.md b/content/de/developer/integration/big-data/seatunnel.md index 0d1ebf67a..256a69d10 100644 --- a/content/de/developer/integration/big-data/seatunnel.md +++ b/content/de/developer/integration/big-data/seatunnel.md @@ -1,13 +1,13 @@ --- title: "SeaTunnel" -description: "Move data between SeaTunnel and RustFS with the S3File connector." +description: "Verschieben Sie Daten zwischen SeaTunnel und RustFS mit dem Connector S3File." --- -This guide connects [Apache SeaTunnel](https://github.com/apache/seatunnel) — the data integration engine — to **RustFS** through the S3File connector. You will run a batch job that generates rows with FakeSource and writes them as JSON files into a RustFS bucket. The workflow was verified with SeaTunnel 2.3.12 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache SeaTunnel](https://github.com/apache/seatunnel) — die Datenintegrations-Engine — über den Connector S3File mit **RustFS**. Sie führen einen Batch-Job aus, der mit FakeSource Zeilen erzeugt und sie als JSON-Dateien in einen RustFS-Bucket schreibt. Der Ablauf wurde mit SeaTunnel 2.3.12 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker and the `rc` client. +Sie benötigen Docker und den Client `rc`. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR Job -->|"S3File sink"| RustFS["RustFS :9000"] ``` -The S3File sink writes through the Hadoop S3A filesystem, so the connector accepts both its own credential options and the standard `fs.s3a.*` Hadoop keys. +Der Sink S3File schreibt über das Hadoop-Dateisystem S3A, daher akzeptiert der Connector sowohl eigene Zugangsdatenoptionen als auch die üblichen Hadoop-Schlüssel `fs.s3a.*`. -## 1. Run the engine +## 1. Die Engine starten -The connector and the Hadoop AWS jars ship inside the image: +Der Connector und die Hadoop-AWS-JARs liegen im Image: ```bash docker run --rm apache/seatunnel:2.3.12 \ @@ -31,9 +31,9 @@ connector-file-s3-2.3.12.jar seatunnel-hadoop-aws.jar ``` -## 2. Write the job config +## 2. Die Job-Konfiguration schreiben -The tricky part: the sink validates `access_key`/`secret_key` at compile time, while the actual S3A client reads the `fs.s3a.*` keys. Provide both, and keep the endpoint without a scheme — the bundled Hadoop version rejects `http://` endpoints: +Der heikle Punkt: der Sink prüft `access_key` und `secret_key` zur Kompilierzeit, während der eigentliche S3A-Client die Schlüssel `fs.s3a.*` liest. Geben Sie beide an und lassen Sie das Schema im Endpunkt weg. Die gebündelte Hadoop-Version lehnt Endpunkte mit `http://` ab: ```text title="seatunnel-rustfs.conf" env { @@ -71,7 +71,7 @@ sink { } ``` -## 3. Run the job +## 3. Den Job ausführen ```bash docker run --rm --network oo-rustfs_default \ @@ -84,7 +84,7 @@ docker run --rm --network oo-rustfs_default \ 2026-10-07 ... INFO ... Submit job finished, job id: 1159846059493556225 ``` -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen ```bash rc ls rustfs/seatunnel-demo/out/ @@ -96,38 +96,38 @@ out/T_1159846059493556225_2de3d99235_0_1_0.json {"id":168282592,"name":"ELyqD","value":1.594479327987022E308} ``` -Five FakeSource rows landed as one JSON file in the bucket. +Fünf Zeilen von FakeSource sind als eine JSON-Datei im Bucket gelandet. -![SeaTunnel output files stored in the RustFS Console](./images/rustfs-seatunnel-out.png) +![In der RustFS-Console gespeicherte SeaTunnel-Ausgabedateien](./images/rustfs-seatunnel-out.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -SeaTunnel in `-e local` mode is stateless. To delete the output: +SeaTunnel im Modus `-e local` ist zustandslos. So löschen Sie die Ausgabe: ```bash rc rm rustfs/seatunnel-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `Plugin PluginIdentifier{... pluginName='S3'} not found` -The sink class is registered as `S3File`, not `S3`. +Die Sink-Klasse ist als `S3File` registriert, nicht als `S3`. ### `There are unconfigured options, the options('access_key', 'secret_key') are required` -The S3File sink requires its own `access_key`/`secret_key` options even when `fs.s3a.*` keys are present. Provide both sets as in step 2. +Der Sink S3File verlangt eigene Optionen `access_key` und `secret_key`, auch wenn Schlüssel `fs.s3a.*` vorhanden sind. Geben Sie beide Sätze wie in Schritt 2 an. ### `No AWS Credentials provided by InstanceProfileCredentialsProvider` -The S3A client on the coordinator side fell back to the instance-profile provider because `fs.s3a.aws.credentials.provider` and the `fs.s3a.access.key`/`fs.s3a.secret.key` pair were missing. Add all three as in step 2. +Der S3A-Client auf der Coordinator-Seite ist auf den Instance-Profile-Provider zurückgefallen, weil `fs.s3a.aws.credentials.provider` und das Paar `fs.s3a.access.key`/`fs.s3a.secret.key` fehlten. Fügen Sie alle drei wie in Schritt 2 hinzu. -### Job hangs on `doesBucketExist` +### Der Job hängt bei `doesBucketExist` -The bundled Hadoop version rejects `http://` scheme endpoints. Use the bare `host:port` form for `fs.s3a.endpoint` and add `fs.s3a.connection.ssl.enabled = "false"`. +Die gebündelte Hadoop-Version lehnt Endpunkte mit dem Schema `http://` ab. Verwenden Sie für `fs.s3a.endpoint` die reine Form `host:port` und fügen Sie `fs.s3a.connection.ssl.enabled = "false"` hinzu. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional SeaTunnel connectors. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [SeaTunnel S3File documentation](https://seatunnel.apache.org/docs/connector-v2/sink/S3File) for parquet/orc formats, partitioned writes, and the matching S3File source. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere SeaTunnel-Connectoren einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [SeaTunnel-Dokumentation zu S3File](https://seatunnel.apache.org/docs/connector-v2/sink/S3File) für die Formate Parquet und ORC, partitionierte Schreibvorgänge und die passende Quelle S3File. diff --git a/content/de/developer/integration/big-data/spark.md b/content/de/developer/integration/big-data/spark.md index 63df078a9..9b084cb43 100644 --- a/content/de/developer/integration/big-data/spark.md +++ b/content/de/developer/integration/big-data/spark.md @@ -171,13 +171,13 @@ docker compose run --rm --entrypoint /bin/sh create-bucket -c \ [2026-09-21 00:58:21] 1.46 KiB spark-demo/events/part-00002-...-c000.snappy.parquet ``` -Sie können das Präfix auch in der RustFS-Konsole anzeigen: +Sie können das Präfix auch in der RustFS Console anzeigen: -![Spark-Parquet-Ausgabe in der RustFS-Konsole](./images/rustfs-spark-objects.png) +![Spark-Parquet-Ausgabe in der RustFS Console](./images/rustfs-spark-objects.png) ## 4. RustFS S3 Tables verwenden -RustFS S3 Tables bietet einen integrierten Apache-Iceberg-REST-Katalog, sodass Spark einen Tabellen-Bucket als verwaltetes Iceberg-Warehouse nutzen kann, während die Daten in RustFS bleiben. Aktivieren Sie einen Tabellen-Bucket und verbinden Sie den Iceberg-REST-Katalog von Spark wie in [S3 Tables](/administration/data/s3-tables) beschrieben: Die REST-Katalog-URI ist `http://:9000/iceberg`, das Warehouse ist der Bucket-Name, und sowohl Kataloganfragen (AWS Signature Version 4, Signing-Name `s3`) als auch der S3-Dateizugriff verwenden pfadbasierte Adressierung (Path-Style). +RustFS S3 Tables bietet einen integrierten Apache-Iceberg-REST-Katalog, sodass Spark einen Tabellen-Bucket als verwaltetes Iceberg-Warehouse nutzen kann, während die Daten in RustFS bleiben. Aktivieren Sie einen Tabellen-Bucket und verbinden Sie den Iceberg-REST-Katalog von Spark wie in [S3 Tables](/de/administration/data/s3-tables) beschrieben: Die REST-Katalog-URI ist `http://:9000/iceberg`, das Warehouse ist der Bucket-Name, und sowohl Kataloganfragen (AWS Signature Version 4, Signing-Name `s3`) als auch der S3-Dateizugriff verwenden pfadbasierte Adressierung (Path-Style). Laut der S3-Tables-Support-Matrix validieren Sie die exakten Spark- und Iceberg-Versionen Ihrer Bereitstellung gegen den Katalog, bevor Sie diesen Pfad in Produktion übernehmen. @@ -215,6 +215,6 @@ docker compose logs create-bucket ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [Spark-Dokumentation](https://spark.apache.org/docs/latest/) für Structured Streaming und Datenquellenoptionen. diff --git a/content/de/developer/integration/big-data/zeppelin.md b/content/de/developer/integration/big-data/zeppelin.md index e7f47375e..4b9b0a5fe 100644 --- a/content/de/developer/integration/big-data/zeppelin.md +++ b/content/de/developer/integration/big-data/zeppelin.md @@ -1,13 +1,13 @@ --- title: "Apache Zeppelin" -description: "Store Apache Zeppelin notebooks in RustFS through the S3 notebook repository." +description: "Speichern Sie Apache-Zeppelin-Notebooks über das S3-Notebook-Repository in RustFS." --- -This guide connects [Apache Zeppelin](https://github.com/apache/zeppelin) — the web-based notebook for data analytics — to **RustFS** through Zeppelin's S3 notebook storage. You will start Zeppelin pointed at a RustFS bucket, create a note, and verify that the notebook file is stored in RustFS and survives a restart. The workflow was verified with `apache/zeppelin:0.12.0` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache Zeppelin](https://github.com/apache/zeppelin) — das webbasierte Notebook für Datenanalyse — über Zeppelins S3-Notebook-Speicher mit **RustFS**. Sie starten Zeppelin mit einem RustFS-Bucket, legen eine Notiz an und prüfen, dass die Notebook-Datei in RustFS liegt und einen Neustart übersteht. Der Ablauf wurde mit `apache/zeppelin:0.12.0` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,18 +15,18 @@ flowchart LR Z -->|".zpln files"| RustFS["RustFS :9000"] ``` -With the `S3NotebookRepo` storage class, every note is persisted as a `.zpln` JSON file under the `user/notebook/` prefix of the bucket. Zeppelin reads and writes the bucket directly, so notes survive container restarts and can be shared between instances. +Mit der Speicherklasse `S3NotebookRepo` wird jede Notiz als JSON-Datei `.zpln` unter dem Präfix `user/notebook/` des Buckets persistiert. Zeppelin liest und schreibt den Bucket direkt, daher überstehen Notizen Container-Neustarts und lassen sich zwischen Instanzen teilen. -## 1. Start Zeppelin +## 1. Zeppelin starten -Create an environment file and replace both credential placeholders: +Legen Sie eine Umgebungsdatei an und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" AWS_ACCESS_KEY_ID= AWS_SECRET_ACCESS_KEY= ``` -Start Zeppelin on the same Docker network as RustFS with the S3 storage settings: +Starten Sie Zeppelin im selben Docker-Netzwerk wie RustFS mit den S3-Speichereinstellungen: ```bash docker run -d --name zeppelin --network oo-rustfs_default \ @@ -40,11 +40,11 @@ docker run -d --name zeppelin --network oo-rustfs_default \ apache/zeppelin:0.12.0 ``` -Zeppelin reads `ZEPPELIN_*` environment variables as configuration properties, so no `zeppelin-site.xml` edit is needed. This guide uses the existing `my-bucket`; notes land under its `user/notebook/` prefix, which the S3 storage creates on demand. +Zeppelin liest Umgebungsvariablen `ZEPPELIN_*` als Konfigurationseigenschaften, daher ist keine Bearbeitung von `zeppelin-site.xml` nötig. Diese Anleitung verwendet den vorhandenen `my-bucket`. Notizen landen unter seinem Präfix `user/notebook/`, das der S3-Speicher bei Bedarf anlegt. -## 2. Create a note +## 2. Eine Notiz anlegen -Wait for the UI on `http://localhost:8080`, then create a note named `rustfs-demo` in the notebook list and add a paragraph, or use the REST API: +Warten Sie auf die Oberfläche unter `http://localhost:8080`, legen Sie dann in der Notebook-Liste eine Notiz namens `rustfs-demo` an und fügen Sie einen Absatz hinzu, oder verwenden Sie die REST-API: ```bash NOTE=$(curl -s -X POST "http://localhost:8080/api/notebook" \ @@ -53,57 +53,57 @@ NOTE=$(curl -s -X POST "http://localhost:8080/api/notebook" \ echo "note id: $NOTE" ``` -## 3. Verify the notebook in RustFS +## 3. Das Notebook in RustFS prüfen -List the notebook prefix: +Listen Sie das Notebook-Präfix auf: ```bash rc ls rustfs/my-bucket/user/notebook/ -r ``` -The note is stored as a JSON file named after the note and its ID: +Die Notiz liegt als JSON-Datei, benannt nach der Notiz und ihrer ID: ```text user/notebook/rustfs-demo_2N4PY7UY5.zpln ``` -![Zeppelin notebooks stored in the RustFS Console](./images/rustfs-zeppelin-notebook.png) +![In der RustFS-Console gespeicherte Zeppelin-Notebooks](./images/rustfs-zeppelin-notebook.png) -Notes survive a restart because Zeppelin loads them from the bucket: +Notizen überstehen einen Neustart, weil Zeppelin sie aus dem Bucket lädt: ```bash docker restart zeppelin curl -s "http://localhost:8080/api/notebook" | head -c 200 ``` -The note list contains `2N4PY7UY5` again after the restart. +Die Notizliste enthält `2N4PY7UY5` nach dem Neustart erneut. -## 4. Stop or reset the deployment +## 4. Die Bereitstellung stoppen oder zurücksetzen -Stop Zeppelin while keeping the notes: +Stoppen Sie Zeppelin und behalten Sie die Notizen: ```bash docker rm -f zeppelin ``` -The notes stay in the `user/notebook/` prefix of `my-bucket`. To delete them, remove the prefix: +Die Notizen bleiben im Präfix `user/notebook/` von `my-bucket`. Um sie zu löschen, entfernen Sie das Präfix: ```bash rc rm rustfs/my-bucket/user/notebook/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### Zeppelin starts but notes never appear in the bucket +### Zeppelin startet, Notizen erscheinen aber nie im Bucket -Confirm the three `ZEPPELIN_NOTEBOOK_S3_*` variables are set and that the credentials environment variables reach the container — the S3 repository is initialized at startup, so the container must be recreated after any change. +Prüfen Sie, dass die drei Variablen `ZEPPELIN_NOTEBOOK_S3_*` gesetzt sind und dass die Umgebungsvariablen der Zugangsdaten den Container erreichen. Das S3-Repository wird beim Start initialisiert, daher muss der Container nach jeder Änderung neu erstellt werden. ### `UnknownHostException: my-bucket.rustfs` -The path-style flag was not picked up. Keep `ZEPPELIN_NOTEBOOK_S3_PATH_STYLE_ACCESS=true` exactly as shown; with path-style disabled Zeppelin treats the bucket as a hostname. +Das Flag für pfadbasierte Adressierung (Path-Style) wurde nicht übernommen. Belassen Sie `ZEPPELIN_NOTEBOOK_S3_PATH_STYLE_ACCESS=true` genau wie gezeigt. Ist die pfadbasierte Adressierung deaktiviert, behandelt Zeppelin den Bucket als Hostnamen. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Zeppelin operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Zeppelin storage documentation](https://zeppelin.apache.org/docs/latest/setup/storage/storage.html#notebook-storage-in-s3) to organize notes in per-user prefixes. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Zeppelin-Operationen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Zeppelin-Speicherdokumentation](https://zeppelin.apache.org/docs/latest/setup/storage/storage.html#notebook-storage-in-s3), um Notizen in Präfixen je Benutzer zu organisieren. diff --git a/content/de/developer/integration/cloud-native/celld.md b/content/de/developer/integration/cloud-native/celld.md index 37e2a757c..29a2b395f 100644 --- a/content/de/developer/integration/cloud-native/celld.md +++ b/content/de/developer/integration/cloud-native/celld.md @@ -1,13 +1,13 @@ --- title: "celld" -description: "Run denoland celld — self-hosted Durable Objects — with fleet state on RustFS." +description: "Betreiben Sie denoland celld — selbst gehostete Durable Objects — mit Fleet-Zustand auf RustFS." --- -This guide connects [celld](https://github.com/denoland/celld) — the self-hosted, distributed Durable Objects runtime from Denoland — to **RustFS** as its fleet bucket. You will run `celld diagnose` against a RustFS bucket (including the conditional-write probe), deploy a Counter worker, mutate Durable Object state over HTTP, restart celld, and confirm the state survives. The workflow was verified with celld v0.6.2 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [celld](https://github.com/denoland/celld) — die selbst gehostete, verteilte Durable-Objects-Laufzeitumgebung von Denoland — mit **RustFS** als Fleet-Bucket. Sie führen `celld diagnose` gegen einen RustFS-Bucket aus (einschließlich der Prüfung auf bedingtes Schreiben), stellen einen Counter-Worker bereit, ändern den Zustand eines Durable Object über HTTP, starten celld neu und bestätigen, dass der Zustand erhalten bleibt. Der Ablauf wurde mit celld v0.6.2 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need the `celld` binary, `esbuild` (for bundling), and Node.js to drive the deployed worker. +Sie benötigen die Binärdatei `celld`, `esbuild` (zum Bündeln) und Node.js, um den bereitgestellten Worker anzusteuern. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,9 +15,9 @@ flowchart LR celld -->|"LTX replicas + ownership + deploy"| RustFS["RustFS :9000"] ``` -celld keeps only a local WAL. Every committed SQLite write is captured in LTX format and uploaded to the fleet bucket; a conditional bucket write (put-if-not-exists) assigns node ownership. The bucket is the source of truth — nodes can crash or restart without losing Durable Object state. +celld behält nur ein lokales WAL. Jeder committete SQLite-Schreibvorgang wird im LTX-Format erfasst und in den Fleet-Bucket hochgeladen. Ein bedingter Bucket-Schreibvorgang (put-if-not-exists) weist die Knoten-Eigentümerschaft zu. Der Bucket ist die Quelle der Wahrheit. Knoten können abstürzen oder neu starten, ohne den Zustand der Durable Objects zu verlieren. -## 1. Install celld +## 1. celld installieren ```bash curl -sLo /tmp/celld.gz \ @@ -31,15 +31,15 @@ celld --version celld 0.6.2 ``` -Install esbuild as well — `celld deploy` bundles workers with it: +Installieren Sie auch esbuild. `celld deploy` bündelt Worker damit: ```bash npm install -g esbuild ``` -## 2. Diagnose the bucket +## 2. Den Bucket prüfen -`celld diagnose` probes the bucket including the conditional write that celld requires for ownership fencing: +`celld diagnose` prüft den Bucket einschließlich des bedingten Schreibens, das celld für das Ownership-Fencing benötigt: ```bash export S3_ENDPOINT=http://:9000 @@ -58,11 +58,11 @@ ok bucket conditional write: create, reject-create, update, reject-stale ok fleet: 0 node lease(s) enumerated ``` -`ok bucket conditional write` is the important line — RustFS supports put-if-not-exists natively, so no fallback storage is needed. +`ok bucket conditional write` ist die wichtige Zeile. RustFS unterstützt put-if-not-exists nativ, daher ist kein Ausweichspeicher nötig. -## 3. Start a node +## 3. Einen Knoten starten -A non-loopback `--listen` requires an explicit `--internal-listen`: +Ein `--listen` außerhalb von Loopback verlangt ein ausdrückliches `--internal-listen`: ```bash nohup celld --bucket s3://celld-demo \ @@ -76,9 +76,9 @@ INFO celld: host runtime initialized event="host_runtime" worker_count=4 INFO celld::fleet: no deployment yet; run `celld deploy` ... ``` -## 4. Deploy the Counter worker +## 4. Den Counter-Worker bereitstellen -Use the counter example from the celld repository — a Durable Object that increments `n` in SQLite storage on every request: +Verwenden Sie das Counter-Beispiel aus dem celld-Repository. Es ist ein Durable Object, das `n` im SQLite-Speicher bei jeder Anfrage erhöht: ```bash curl -sLo /tmp/celld.zip https://codeload.github.com/denoland/celld/zip/refs/tags/v0.6.2 @@ -93,9 +93,9 @@ Uploaded counter (0.02 sec) Current Version ID: bf5806589892a6cc ``` -## 5. Mutate Durable Object state +## 5. Den Zustand des Durable Object ändern -Each request routes to the `Counter` Durable Object, which reads `n` from storage, increments, and writes it back: +Jede Anfrage wird an das Durable Object `Counter` geleitet, das `n` aus dem Speicher liest, erhöht und zurückschreibt: ```bash curl -s "http://127.0.0.1:18080/?name=rustfs" @@ -109,9 +109,9 @@ curl -s "http://127.0.0.1:18080/?name=rustfs" {"n":3,"url":"http://127.0.0.1:18080/?name=rustfs"} ``` -## 6. Restart celld and verify persistence +## 6. celld neu starten und die Persistenz prüfen -Kill the node, start it again, and hit the same URL — the counter continues from where it stopped, because the state was in RustFS the whole time: +Beenden Sie den Knoten, starten Sie ihn erneut und rufen Sie dieselbe URL auf. Der Zähler setzt dort fort, wo er aufgehört hat, weil der Zustand die ganze Zeit in RustFS lag: ```bash pkill -f "celld --bucket" @@ -126,7 +126,7 @@ curl -s "http://127.0.0.1:18080/?name=rustfs" {"n":4,"url":"http://127.0.0.1:18080/?name=rustfs"} ``` -List the bucket — the fleet state is all there: +Listen Sie den Bucket auf. Der Fleet-Zustand liegt vollständig dort: ```bash rc ls rustfs/celld-demo/ -r | head -5 @@ -139,35 +139,35 @@ deploy/counter/bf5806589892a6cc/index.js deploy/counter/current.json ``` -![celld state stored in the RustFS Console](./images/rustfs-celld-state.png) +![In der RustFS-Console gespeicherter celld-Zustand](./images/rustfs-celld-state.png) -## 7. Stop or reset +## 7. Stoppen oder zurücksetzen ```bash pkill -f "celld --bucket" rc rm rustfs/celld-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `bind --listen 127.0.0.0.1:8080 ... Address already in use` -Port 8080 is commonly taken (a local GitLab registry or dev server). Move the Worker listener: `--listen 0.0.0.0:18080`. +Port 8080 ist häufig belegt (eine lokale GitLab-Registry oder ein Entwicklungsserver). Verschieben Sie den Worker-Listener: `--listen 0.0.0.0:18080`. ### `a non-loopback --listen requires an explicit --internal-listen` -Binding a public interface requires a separate peer listener: add `--internal-listen 0.0.0.0:9099 --advertise 127.0.0.1:9099`. +Das Binden einer öffentlichen Schnittstelle verlangt einen eigenen Peer-Listener: fügen Sie `--internal-listen 0.0.0.0:9099 --advertise 127.0.0.1:9099` hinzu. ### `esbuild not found` -`celld deploy` bundles the worker with esbuild. Install it globally (`npm install -g esbuild`) or point `CELLD_ESBUILD` at the binary. +`celld deploy` bündelt den Worker mit esbuild. Installieren Sie es global (`npm install -g esbuild`) oder zeigen Sie mit `CELLD_ESBUILD` auf die Binärdatei. -### `celld deploy` on the example prints `unknown command init for argo` at runtime +### `celld deploy` auf dem Beispiel gibt zur Laufzeit `unknown command init for argo` aus -That means the executor container/pod is running an `argo` CLI binary instead of argoexec — a sign the wrong image was tagged as the executor in your cluster setup, unrelated to celld itself. On a plain host (no cluster) this does not occur. +Das bedeutet, dass der Executor-Container oder -Pod eine `argo`-CLI-Binärdatei statt argoexec ausführt. Das ist ein Zeichen, dass im Cluster-Setup das falsche Image als Executor getaggt wurde, und hat mit celld selbst nichts zu tun. Auf einem einfachen Host ohne Cluster tritt das nicht auf. -## Next steps +## Nächste Schritte -- Compare with the [Cloudflare Durable Objects documentation](https://developers.cloudflare.com/durable-objects/) — celld runs the same programming model on your own bucket. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [celld README](https://github.com/denoland/celld) for multi-node fleets: point a second node at the same bucket and let conditional writes elect the owner. +- Vergleichen Sie die Anleitung mit der [Cloudflare-Dokumentation zu Durable Objects](https://developers.cloudflare.com/durable-objects/). celld betreibt dasselbe Programmiermodell auf Ihrem eigenen Bucket. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [celld-README](https://github.com/denoland/celld) für Fleets mit mehreren Knoten: richten Sie einen zweiten Knoten auf denselben Bucket aus und lassen Sie bedingte Schreibvorgänge den Eigentümer wählen. diff --git a/content/de/developer/integration/cloud-native/cortex.md b/content/de/developer/integration/cloud-native/cortex.md index 3db19b471..8524e05bd 100644 --- a/content/de/developer/integration/cloud-native/cortex.md +++ b/content/de/developer/integration/cloud-native/cortex.md @@ -1,13 +1,13 @@ --- title: "Cortex" -description: "Run Cortex with RustFS as the S3-compatible blocks, ruler, and alertmanager storage backend." +description: "Betreiben Sie Cortex mit RustFS als S3-kompatiblem Speicher-Backend für Blöcke, Ruler und Alertmanager." --- -This guide connects [Cortex](https://github.com/cortexproject/cortex) — the horizontally scalable Prometheus-compatible metrics backend — to **RustFS** through Cortex's native S3 bucket storage. You will run Cortex in single-binary mode with blocks, ruler, and alertmanager storage pointed at a RustFS bucket, push metrics with remote write, store a rule group, and verify the objects. The workflow was verified with `cortexproject/cortex:v1.21.1` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Cortex](https://github.com/cortexproject/cortex) — das horizontal skalierbare, Prometheus-kompatible Metrik-Backend — über den nativen S3-Bucket-Speicher von Cortex mit **RustFS**. Sie betreiben Cortex im Single-Binary-Modus, richten den Speicher für Blöcke, Ruler und Alertmanager auf einen RustFS-Bucket aus, senden Metriken per Remote Write, speichern eine Regelgruppe und prüfen die Objekte. Der Ablauf wurde mit `cortexproject/cortex:v1.21.1` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR Cortex -->|"blocks, rules, configs"| RustFS["RustFS :9000"] ``` -Cortex stores every TSDB block, ruler rule group, and alertmanager configuration in object storage. Pointing the `s3` backend at RustFS makes the bucket the single source of truth for all tenant data. +Cortex speichert jeden TSDB-Block, jede Ruler-Regelgruppe und jede Alertmanager-Konfiguration im Objektspeicher. Wenn Sie das Backend `s3` auf RustFS ausrichten, wird der Bucket zur einzigen Quelle der Wahrheit für alle Tenant-Daten. -## 1. Create the Cortex config +## 1. Die Cortex-Konfiguration anlegen -Create the config file, replacing all connection placeholders: +Legen Sie die Konfigurationsdatei an und ersetzen Sie alle Verbindungsplatzhalter: ```yaml title="cortex.yaml" target: all @@ -88,11 +88,11 @@ alertmanager_storage: <<: *s3 ``` -Cortex names the bucket field `bucket_name` and controls addressing with `bucket_lookup_type: path`. `insecure: true` allows the plain-HTTP endpoint. The `block_ranges_period` and `ship_interval` values shorten the block cycle so the test produces objects quickly; keep the defaults in production. +Cortex nennt das Bucket-Feld `bucket_name` und wählt mit `bucket_lookup_type: path` pfadbasierte Adressierung (Path-Style). `insecure: true` erlaubt den Endpunkt mit unverschlüsseltem HTTP. Die Werte `block_ranges_period` und `ship_interval` verkürzen den Blockzyklus, damit der Test schnell Objekte erzeugt. Behalten Sie in der Produktion die Standardwerte. -## 2. Run Cortex +## 2. Cortex starten -Create the bucket and start Cortex on the same Docker network as RustFS: +Legen Sie den Bucket an und starten Sie Cortex im selben Docker-Netzwerk wie RustFS: ```bash rc mb rustfs/cortex @@ -107,9 +107,9 @@ docker run -d --name cortex --network oo-rustfs_default -p 9009:9009 \ ts=... caller=cortex.go:469 level=info msg="Cortex started" ``` -## 3. Push metrics and rules +## 3. Metriken und Regeln senden -Start a Prometheus that scrapes itself and remote-writes into Cortex: +Starten Sie einen Prometheus, der sich selbst scrapt und per Remote Write nach Cortex schreibt: ```yaml title="prometheus.yml" global: @@ -128,7 +128,7 @@ docker run -d --name prom-writer --network oo-rustfs_default \ prom/prometheus:latest --config.file=/etc/prometheus/prometheus.yml ``` -Store a rule group through the ruler API: +Speichern Sie eine Regelgruppe über die Ruler-API: ```bash cat > rules.yaml << "EOF" @@ -151,7 +151,7 @@ curl -s -o /dev/null -w "%{http_code}\n" \ 202 ``` -Query the ingested series back: +Fragen Sie die aufgenommenen Serien zurück: ```bash curl -s "http://localhost:9009/prometheus/api/v1/query?query=up" @@ -161,15 +161,15 @@ curl -s "http://localhost:9009/prometheus/api/v1/query?query=up" {"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"up",...},"value":[...,"1"]}]}} ``` -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen -List the bucket prefixes: +Listen Sie die Bucket-Präfixe auf: ```bash rc ls rustfs/cortex/ -r ``` -The ruler config landed immediately, and the ingester shipped two TSDB blocks (each with `chunks`, `index`, and `meta.json`): +Die Ruler-Konfiguration ist sofort angekommen, und der Ingester hat zwei TSDB-Blöcke ausgeliefert (jeder mit `chunks`, `index` und `meta.json`): ```text fake/01M35WE4B1G6RRKHRV0HSGADY1/chunks/000001 @@ -181,38 +181,38 @@ fake/01M35WWS2YCC7FBK1JSBKFQGRP/meta.json rules/fake/cnVzdGZzLWRlbW8=/cnVzdGZzLWRlbW8= ``` -![Cortex blocks and rules stored in the RustFS Console](./images/rustfs-cortex-blocks.png) +![In der RustFS-Console gespeicherte Cortex-Blöcke und Regeln](./images/rustfs-cortex-blocks.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -To tear down the demo while keeping the bucket objects: +Um die Demo abzubauen und die Bucket-Objekte zu behalten: ```bash docker rm -f cortex prom-writer ``` -To delete the stored data: +Um die gespeicherten Daten zu löschen: ```bash rc rm rustfs/cortex/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `field bucket not found in type s3.Config` -Cortex uses `bucket_name`, not `bucket`. Path-style addressing is set with `bucket_lookup_type: path` — the `force_path_style` key used by Thanos does not exist in Cortex. +Cortex verwendet `bucket_name`, nicht `bucket`. Die pfadbasierte Adressierung setzen Sie mit `bucket_lookup_type: path`. Den Schlüssel `force_path_style`, den Thanos verwendet, gibt es in Cortex nicht. -### Blocks never appear in the bucket +### Blöcke erscheinen nie im Bucket -The ingester only ships a block after the head is compacted at a `block_ranges_period` boundary (default 2h). For tests, set a small range such as `[15m]` together with `ship_interval: 30s` and wait for one period. +Der Ingester liefert einen Block erst aus, nachdem der Head an einer Grenze von `block_ranges_period` kompaktiert wurde (Standard 2h). Setzen Sie für Tests einen kleinen Bereich wie `[15m]` zusammen mit `ship_interval: 30s` und warten Sie eine Periode ab. -### `Unauthorized` or empty bucket listings +### `Unauthorized` oder leere Bucket-Auflistungen -Confirm `access_key_id` and `secret_access_key` are present in every `s3` block that uses the bucket, and that `insecure: true` matches the plain-HTTP endpoint. +Prüfen Sie, dass `access_key_id` und `secret_access_key` in jedem `s3`-Block vorhanden sind, der den Bucket verwendet, und dass `insecure: true` zum Endpunkt mit unverschlüsseltem HTTP passt. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Cortex storage options. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Combine Cortex with [Thanos](/developer/integration/observability/thanos) when you need block storage for long-term Prometheus data as well. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Cortex-Speicheroptionen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Kombinieren Sie Cortex mit [Thanos](/de/developer/integration/observability/thanos), wenn Sie Blockspeicher auch für langfristige Prometheus-Daten brauchen. diff --git a/content/de/developer/integration/cloud-native/flux.md b/content/de/developer/integration/cloud-native/flux.md index 0319cc855..3a716628e 100644 --- a/content/de/developer/integration/cloud-native/flux.md +++ b/content/de/developer/integration/cloud-native/flux.md @@ -1,13 +1,13 @@ --- title: "Flux" -description: "Deliver Kubernetes manifests to Flux CD from RustFS through the Bucket source API." +description: "Liefern Sie Kubernetes-Manifeste über die Bucket-Source-API aus RustFS an Flux CD." --- -This guide connects [Flux CD](https://github.com/fluxcd/flux2) — the GitOps toolkit for Kubernetes — to **RustFS** through the source-controller Bucket API. You will seed a RustFS bucket with Kubernetes manifests, register the bucket as a Flux `Bucket` source with the `generic` provider, and let a Kustomization apply everything it contains. The workflow was verified with `flux v2.9.5` (source-controller) on `k3s v1.36.4+k3s1` against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Flux CD](https://github.com/fluxcd/flux2) — das GitOps-Toolkit für Kubernetes — über die Bucket-API des Source-Controllers mit **RustFS**. Sie befüllen einen RustFS-Bucket mit Kubernetes-Manifesten, registrieren den Bucket als Flux-Quelle `Bucket` mit dem Provider `generic` und lassen eine Kustomization alles anwenden, was er enthält. Der Ablauf wurde mit `flux v2.9.5` (source-controller) auf `k3s v1.36.4+k3s1` gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need a Kubernetes cluster with Flux installed (`flux install`) and the `rc` client. This deployment is intended for local integration testing, not production. +Sie benötigen einen Kubernetes-Cluster mit installiertem Flux (`flux install`) und den Client `rc`. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -17,11 +17,11 @@ flowchart LR kustomize-controller -->|"apply"| Cluster["Kubernetes cluster"] ``` -The source-controller lists and downloads objects from the bucket over the S3 API, packs them into an artifact, and the kustomize-controller applies the manifests from that artifact. RustFS acts as the pull-based source of truth for the cluster. +Der Source-Controller listet Objekte aus dem Bucket über die S3-API und lädt sie herunter, packt sie in ein Artefakt, und der Kustomize-Controller wendet die Manifeste aus diesem Artefakt an. RustFS dient als pull-basierte Quelle der Wahrheit für den Cluster. -## 1. Seed the bucket +## 1. Den Bucket befüllen -Store a Kustomize overlay in the bucket, replacing all connection placeholders: +Speichern Sie ein Kustomize-Overlay im Bucket und ersetzen Sie alle Verbindungsplatzhalter: ```yaml title="clusters/staging/kustomization.yaml" apiVersion: kustomize.config.k8s.io/v1beta1 @@ -41,7 +41,7 @@ data: source: s3-bucket ``` -Upload the files: +Laden Sie die Dateien hoch: ```bash rc mb rustfs/flux-src @@ -54,9 +54,9 @@ staging/kustomization.yaml staging/rustfs-demo-configmap.yaml ``` -## 2. Create the credentials secret +## 2. Das Zugangsdaten-Secret anlegen -Flux reads the credentials from a secret in the same namespace as the source, using lowercase keys: +Flux liest die Zugangsdaten aus einem Secret im selben Namespace wie die Quelle und verwendet kleingeschriebene Schlüssel: ```bash kubectl -n flux-system create secret generic rustfs-creds \ @@ -64,11 +64,11 @@ kubectl -n flux-system create secret generic rustfs-creds \ --from-literal=secretkey= ``` -The field names must be `accesskey` and `secretkey` — capitalization such as `accessKey` fails with an `AuthenticationFailed` status. +Die Feldnamen müssen `accesskey` und `secretkey` lauten. Eine Schreibweise wie `accessKey` schlägt mit dem Status `AuthenticationFailed` fehl. -## 3. Register the Bucket source +## 3. Die Bucket-Quelle registrieren -Create the Bucket source with the `generic` provider: +Legen Sie die Bucket-Quelle mit dem Provider `generic` an: ```bash flux create source bucket rustfs-demo \ @@ -85,18 +85,18 @@ flux create source bucket rustfs-demo \ ✔ Bucket source reconciliation completed ``` -If reconciliation is still running, check the status with `flux get sources bucket`: +Wenn die Reconciliation noch läuft, prüfen Sie den Status mit `flux get sources bucket`: ```text NAME REVISION SUSPENDED READY MESSAGE rustfs-demo sha256:481816d1 False True stored artifact: revision 'sha256:481816d1' ``` -The `generic` provider uses path-style requests and plain HTTP with `--insecure`, so the endpoint is the bare `host:port`. +Der Provider `generic` verwendet Anfragen mit pfadbasierter Adressierung (Path-Style) und unverschlüsseltes HTTP mit `--insecure`, daher ist der Endpunkt die reine Form `host:port`. -## 4. Apply the manifests +## 4. Die Manifeste anwenden -Create a Kustomization that consumes the artifact: +Legen Sie eine Kustomization an, die das Artefakt verwendet: ```bash flux create kustomization rustfs-demo \ @@ -111,7 +111,7 @@ flux create kustomization rustfs-demo \ ✔ applied revision sha256:481816d1 ``` -Confirm the manifest landed on the cluster: +Bestätigen Sie, dass das Manifest im Cluster angekommen ist: ```bash kubectl -n default get configmap rustfs-flux-demo -o jsonpath="{.data}" @@ -121,37 +121,37 @@ kubectl -n default get configmap rustfs-flux-demo -o jsonpath="{.data}" {"source":"s3-bucket","storage":"rustfs"} ``` -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -Suspend or delete the Flux resources without touching the bucket: +Setzen Sie die Flux-Ressourcen aus oder löschen Sie sie, ohne den Bucket anzufassen: ```bash flux suspend source bucket rustfs-demo --namespace=flux-system flux delete kustomization rustfs-demo --namespace=flux-system ``` -To delete the bucket contents: +Um den Bucket-Inhalt zu löschen: ```bash rc rm rustfs/flux-src/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `invalid 'rustfs-creds' secret data: required fields 'accesskey' and 'secretkey'` -The secret keys are lowercase. Recreate the secret with `accesskey` and `secretkey` as literal key names. +Die Secret-Schlüssel sind kleingeschrieben. Legen Sie das Secret mit `accesskey` und `secretkey` als literalen Schlüsselnamen neu an. -### Reconciliation never becomes ready +### Die Reconciliation wird nie bereit -Confirm the endpoint is reachable from inside the cluster — pods cannot use `localhost`, so point the source at the host IP or the Docker bridge gateway (commonly `172.17.0.1`) that publishes the RustFS port. `--insecure` is required for plain HTTP. +Prüfen Sie, dass der Endpunkt aus dem Cluster heraus erreichbar ist. Pods können `localhost` nicht verwenden, richten Sie die Quelle daher auf die Host-IP oder das Docker-Bridge-Gateway (häufig `172.17.0.1`), das den RustFS-Port veröffentlicht. `--insecure` ist für unverschlüsseltes HTTP erforderlich. -### `AuthenticationFailed` despite valid credentials +### `AuthenticationFailed` trotz gültiger Zugangsdaten -Check that the secret lives in the same namespace as the Bucket source and that the keys have no trailing whitespace or quoting. +Prüfen Sie, dass das Secret im selben Namespace wie die Bucket-Quelle liegt und dass die Schlüssel kein nachgestelltes Leerzeichen und keine zusätzlichen Anführungszeichen enthalten. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional source types. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Flux Bucket source documentation](https://fluxcd.io/flux/components/source/buckets/) to combine bucket sources with Helm releases and image automation. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Quelltypen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Flux-Dokumentation zur Bucket-Quelle](https://fluxcd.io/flux/components/source/buckets/), um Bucket-Quellen mit Helm-Releases und Image-Automation zu kombinieren. diff --git a/content/de/developer/integration/cloud-native/index.md b/content/de/developer/integration/cloud-native/index.md index e703d7a73..1e8e7d509 100644 --- a/content/de/developer/integration/cloud-native/index.md +++ b/content/de/developer/integration/cloud-native/index.md @@ -1,14 +1,14 @@ --- -title: "Cloud Native" -description: "Connect cloud native platforms to RustFS through S3-compatible object storage interfaces." +title: "Cloud-native" +description: "Verbinden Sie cloud-native Plattformen über S3-kompatible Objektspeicher-Schnittstellen mit RustFS." --- -Use **RustFS** as the object storage layer for cloud native platforms that support an S3-compatible endpoint. +Nutzen Sie **RustFS** als Objektspeicher-Backend für cloud-native Plattformen mit S3-kompatiblem Endpunkt. -## Platforms +## Plattformen - [Cortex](./cortex.md) - [Flux](./flux.md) - [celld](./celld.md) -Keep platform state in a dedicated bucket, and use credentials scoped to the required bucket operations. +Halten Sie den Plattformzustand in einem eigenen Bucket und verwenden Sie Zugangsdaten, die auf die erforderlichen Bucket-Operationen beschränkt sind. diff --git a/content/de/developer/integration/cloud-native/meta.json b/content/de/developer/integration/cloud-native/meta.json index fbe75f4b9..f41fcbe2c 100644 --- a/content/de/developer/integration/cloud-native/meta.json +++ b/content/de/developer/integration/cloud-native/meta.json @@ -1,5 +1,5 @@ { - "title": "Cloud Native", + "title": "Cloud-native", "pages": [ "cortex", "flux", diff --git a/content/de/developer/integration/database/clickhouse.md b/content/de/developer/integration/database/clickhouse.md index ac9d8d4b2..635ad8bea 100644 --- a/content/de/developer/integration/database/clickhouse.md +++ b/content/de/developer/integration/database/clickhouse.md @@ -1,13 +1,13 @@ --- title: "ClickHouse" -description: "Run ClickHouse with an S3 disk backed by RustFS for MergeTree table data." +description: "Betreiben Sie ClickHouse mit einer S3-Disk auf RustFS für MergeTree-Tabellendaten." --- -This guide connects [ClickHouse](https://github.com/ClickHouse/ClickHouse) — the real-time OLAP database — to **RustFS** through ClickHouse's S3 disk storage policy. You will start a ClickHouse server with Docker, create a MergeTree table that stores its parts on RustFS, insert rows, and verify that the table data lives in the bucket. The workflow was verified with `clickhouse/clickhouse-server:25.8` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [ClickHouse](https://github.com/ClickHouse/ClickHouse) — die OLAP-Datenbank für Echtzeitanalysen — über die Speicher-Policy der S3-Disk von ClickHouse mit **RustFS**. Sie starten einen ClickHouse-Server mit Docker, legen eine MergeTree-Tabelle an, die ihre Parts auf RustFS speichert, fügen Zeilen ein und prüfen, dass die Tabellendaten im Bucket liegen. Der Ablauf wurde mit `clickhouse/clickhouse-server:25.8` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,18 +15,18 @@ flowchart LR CH -->|"MergeTree parts"| RustFS["RustFS :9000"] ``` -The `rustfs` disk is a ClickHouse S3 disk pointed at the `clickhouse-data` bucket. Tables created with the matching storage policy write their parts — data, index, and checksum files — to the bucket instead of the local filesystem. +Die Disk `rustfs` ist eine ClickHouse-S3-Disk, die auf den Bucket `clickhouse-data` zeigt. Tabellen mit der passenden Speicher-Policy schreiben ihre Parts — Daten-, Index- und Prüfsummendateien — in den Bucket statt auf das lokale Dateisystem. -## 1. Create the project files +## 1. Projektdateien anlegen -Create the bucket first — ClickHouse does not create buckets: +Legen Sie zuerst den Bucket an. ClickHouse legt keine Buckets an: ```bash rc alias set rustfs http://:9000 rc mb rustfs/clickhouse-data ``` -Create the storage configuration, replacing both credential placeholders: +Legen Sie die Speicherkonfiguration an und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```xml title="storage.xml" @@ -52,9 +52,9 @@ Create the storage configuration, replacing both credential placeholders: ``` -The endpoint must end with `/` and includes the bucket name as the first path segment. Inside the Compose network the hostname is `rustfs`; from the host use `http://localhost:9000/clickhouse-data/`. +Der Endpunkt muss mit `/` enden und enthält den Bucket-Namen als erstes Pfadsegment. Innerhalb des Compose-Netzwerks lautet der Hostname `rustfs`. Vom Host aus verwenden Sie `http://localhost:9000/clickhouse-data/`. -Start ClickHouse with the configuration mounted: +Starten Sie ClickHouse mit eingehängter Konfiguration: ```bash docker run -d --name clickhouse --network oo-rustfs_default \ @@ -64,9 +64,9 @@ docker run -d --name clickhouse --network oo-rustfs_default \ clickhouse/clickhouse-server:25.8 ``` -## 2. Create a table on the S3 disk +## 2. Eine Tabelle auf der S3-Disk anlegen -Wait for the HTTP interface, then create a database and a MergeTree table with the storage policy: +Warten Sie auf die HTTP-Schnittstelle und legen Sie dann eine Datenbank und eine MergeTree-Tabelle mit der Speicher-Policy an: ```bash curl "http://localhost:8123/?password=" \ @@ -83,7 +83,7 @@ curl "http://localhost:8123/?password=" \ VALUES (1, 'clickhouse-on-rustfs'), (2, 'second')" ``` -Read the rows back and confirm ClickHouse reports the part on the `rustfs` disk: +Lesen Sie die Zeilen zurück und bestätigen Sie, dass ClickHouse den Part auf der Disk `rustfs` meldet: ```bash curl "http://localhost:8123/?password=" \ @@ -99,15 +99,15 @@ curl "http://localhost:8123/?password=" \ all_1_1_0 rustfs ``` -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/clickhouse-data/ -r ``` -ClickHouse writes each part as content-addressed blobs. The output contains several small objects, and the count grows as more parts are written: +ClickHouse schreibt jeden Part als inhaltsadressierte Blobs. Die Ausgabe enthält mehrere kleine Objekte, und die Anzahl wächst, wenn weitere Parts geschrieben werden: ```text dtg/hpsyncexixvdnsgorvseobogcgowg @@ -115,9 +115,9 @@ dzp/zfblobhsatzdveqdrsfqcupkdehja izg/gvhchqobrizpkdftuvlmakkoutwps ``` -![ClickHouse parts stored in the RustFS Console](./images/rustfs-clickhouse-disk.png) +![In der RustFS-Console gespeicherte ClickHouse-Parts](./images/rustfs-clickhouse-disk.png) -The data survives a container restart because the parts live in RustFS: +Die Daten überstehen einen Container-Neustart, weil die Parts in RustFS liegen: ```bash docker restart clickhouse @@ -125,36 +125,36 @@ curl "http://localhost:8123/?password=" \ --data-binary "SELECT count() FROM rustfs_demo.events" ``` -## 4. Stop or reset the deployment +## 4. Die Bereitstellung stoppen oder zurücksetzen -Stop the server while keeping the data: +Stoppen Sie den Server und behalten Sie die Daten: ```bash docker rm -f clickhouse ``` -The parts stay in the `clickhouse-data` bucket and the table can be queried again after the next start. To delete the data, remove the bucket: +Die Parts bleiben im Bucket `clickhouse-data`, und die Tabelle lässt sich nach dem nächsten Start erneut abfragen. Um die Daten zu löschen, entfernen Sie den Bucket: ```bash rc rb rustfs/clickhouse-data --force ``` -## Troubleshooting +## Fehlerbehebung -### `REQUIRED_PASSWORD` on every query +### `REQUIRED_PASSWORD` bei jeder Abfrage -ClickHouse 25.8 images require a password for the `default` user. Set `CLICKHOUSE_PASSWORD` on the container and pass the same value as the `password` query parameter, as shown above. +Images von ClickHouse 25.8 verlangen ein Passwort für den Benutzer `default`. Setzen Sie `CLICKHOUSE_PASSWORD` am Container und übergeben Sie denselben Wert als Abfrageparameter `password`, wie oben gezeigt. -### Table creation fails with a disk or endpoint error +### Das Anlegen der Tabelle schlägt mit einem Disk- oder Endpunktfehler fehl -Confirm that the bucket exists before the table is created, that the endpoint ends with `/`, and that the credentials match the RustFS deployment. Check the server log for the underlying S3 error: +Prüfen Sie, dass der Bucket existiert, bevor die Tabelle angelegt wird, dass der Endpunkt mit `/` endet und dass die Zugangsdaten zur RustFS-Bereitstellung passen. Prüfen Sie das Server-Log auf den zugrunde liegenden S3-Fehler: ```bash docker logs clickhouse | grep -i s3 | tail ``` -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional ClickHouse operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [ClickHouse S3 disk documentation](https://clickhouse.com/docs/engines/table-engines/mergetree-family/mergetree#table_engine-mergetree-s3) to add a cache disk or a tiered hot/cold policy. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere ClickHouse-Operationen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [ClickHouse-Dokumentation zur S3-Disk](https://clickhouse.com/docs/engines/table-engines/mergetree-family/mergetree#table_engine-mergetree-s3), um eine Cache-Disk oder eine Policy für gestufte Speicherung mit heißer und kalter Stufe hinzuzufügen. diff --git a/content/de/developer/integration/database/databend.md b/content/de/developer/integration/database/databend.md index 829763398..383a44c7d 100644 --- a/content/de/developer/integration/database/databend.md +++ b/content/de/developer/integration/database/databend.md @@ -1,13 +1,13 @@ --- title: "Databend" -description: "Run Databend with RustFS as the S3-compatible storage backend." +description: "Betreiben Sie Databend mit RustFS als S3-kompatiblem Objektspeicher-Backend." --- -This guide connects [Databend](https://github.com/datafuselabs/databend) — the open-source cloud data warehouse — to **RustFS** as its object storage backend. You will start the meta service and query node, point the storage backend at a RustFS bucket, create a database and table, and verify the Parquet files in the bucket. The workflow was verified with Databend v1.2.925-patch-13 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Databend](https://github.com/datafuselabs/databend) — das quelloffene Cloud-Data-Warehouse — mit **RustFS** als Objektspeicher-Backend. Sie starten den Meta-Dienst und den Query-Knoten, richten das Speicher-Backend auf einen RustFS-Bucket aus, legen eine Datenbank und eine Tabelle an und prüfen die Parquet-Dateien im Bucket. Der Ablauf wurde mit Databend v1.2.925-patch-13 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need the Databend release tarball on a Linux host (or Docker). This deployment is intended for local integration testing, not production. +Sie benötigen das Release-Tarball von Databend auf einem Linux-Host (oder Docker). Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,11 +16,11 @@ flowchart LR Query -->|"Parquet SSTs + indexes"| RustFS["RustFS :9000"] ``` -Databend stores table data as Parquet files with bloom-filter indexes in object storage, so the bucket holds the entire table dataset and the query node stays stateless. +Databend speichert Tabellendaten als Parquet-Dateien mit Bloom-Filter-Indizes im Objektspeicher. Der Bucket enthält damit den gesamten Tabellendatensatz, und der Query-Knoten bleibt zustandslos. -## 1. Download and install +## 1. Herunterladen und installieren -Grab a release tarball and unpack the binaries: +Laden Sie ein Release-Tarball herunter und entpacken Sie die Binärdateien: ```bash curl -Lo /tmp/databend.tgz \ @@ -28,15 +28,15 @@ curl -Lo /tmp/databend.tgz \ tar -xzf /tmp/databend.tgz -C /opt ``` -Create the data directories: +Legen Sie die Datenverzeichnisse an: ```bash mkdir -p /opt/databend/data /opt/databend/logs /opt/databend/meta-logs ``` -## 2. Configure the meta service +## 2. Den Meta-Dienst konfigurieren -Create `databend-meta.toml` — note the top-level addresses and the `[raft_config]` section with `single = true`: +Legen Sie `databend-meta.toml` an. Beachten Sie die Adressen auf oberster Ebene und den Abschnitt `[raft_config]` mit `single = true`: ```toml title="databend-meta.toml" admin_api_address = "0.0.0.0:28002" @@ -57,9 +57,9 @@ raft_advertise_host = "127.0.0.1" single = true ``` -## 3. Configure the query node +## 3. Den Query-Knoten konfigurieren -Create `databend-query.toml`. The `tenant_id` and `cluster_id` keys must live inside the `[query]` section, and `[storage.s3]` points at RustFS: +Legen Sie `databend-query.toml` an. Die Schlüssel `tenant_id` und `cluster_id` müssen im Abschnitt `[query]` stehen, und `[storage.s3]` zeigt auf RustFS: ```toml title="databend-query.toml" [query] @@ -96,9 +96,9 @@ secret_access_key = "" enable_virtual_host_style = false ``` -Keep all keys before the `[[query.users]]` array entry — TOML treats everything after it as part of that array element, and misplaced keys fail validation with confusing errors. +Belassen Sie alle Schlüssel vor dem Array-Eintrag `[[query.users]]`. TOML behandelt alles danach als Teil dieses Array-Elements, und falsch platzierte Schlüssel scheitern bei der Validierung mit irreführenden Fehlern. -## 4. Start the services +## 4. Die Dienste starten ```bash nohup /opt/databend/bin/databend-meta -c /opt/databend/databend-meta.toml > /opt/databend/meta.out 2>&1 & @@ -107,9 +107,9 @@ nohup /opt/databend/bin/databend-query -c /opt/databend/databend-query.toml > /o sleep 20 ``` -## 5. Create a table and query +## 5. Eine Tabelle anlegen und abfragen -Databend serves an HTTP API on port 8000. Create a database and a table, insert rows, and read them back — quotes inside SQL must be single quotes (double quotes mean identifiers): +Databend stellt eine HTTP-API auf Port 8000 bereit. Legen Sie eine Datenbank und eine Tabelle an, fügen Sie Zeilen ein und lesen Sie sie zurück. Anführungszeichen innerhalb von SQL müssen einfache Anführungszeichen sein. Doppelte Anführungszeichen bedeuten Bezeichner: ```bash curl -s -m 90 -u databend: http://127.0.0.1:8000/v1/query \ @@ -129,9 +129,9 @@ curl -s -m 120 -u databend: http://127.0.0.1:8000/v1/query \ {"id":"...","state":"Succeeded",...,"data":[["1","alpha"],["2","beta"],["3","gamma"]],...} ``` -## 6. Verify objects in RustFS +## 6. Objekte in RustFS prüfen -List the bucket — the table lives as Parquet blocks with index files under numeric prefixes: +Listen Sie den Bucket auf. Die Tabelle liegt als Parquet-Blöcke mit Indexdateien unter numerischen Präfixen: ```bash rc ls rustfs/databend-demo/ -r | head -4 @@ -142,35 +142,35 @@ rc ls rustfs/databend-demo/ -r | head -4 73/116/_i_b_v2/01a1192b11b07c38b9ae1178abc78882_v4.parquet ``` -![Databend Parquet files stored in the RustFS Console](./images/rustfs-databend-parquet.png) +![In der RustFS-Console gespeicherte Databend-Parquet-Dateien](./images/rustfs-databend-parquet.png) -## 7. Stop or reset +## 7. Stoppen oder zurücksetzen ```bash pkill -f databend-query; pkill -f databend-meta rc rm rustfs/databend-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `cluster_id is empty without resources management` -`tenant_id` and `cluster_id` were placed outside the `[query]` section. In TOML, every key belongs to the most recent section header — move them back under `[query]`. +`tenant_id` und `cluster_id` standen außerhalb des Abschnitts `[query]`. In TOML gehört jeder Schlüssel zum letzten Abschnittskopf. Verschieben Sie sie zurück unter `[query]`. ### `CannotListenerPort ... 127.0.0.1:9090` -The flight API defaults to 9090, which other local services often occupy. Set `flight_api_address`, `metric_api_address`, and `admin_api_address` to free ports inside `[query]`. +Die Flight-API verwendet standardmäßig 9090, das andere lokale Dienste oft belegen. Setzen Sie `flight_api_address`, `metric_api_address` und `admin_api_address` innerhalb von `[query]` auf freie Ports. -### Query returns `Authentication error: no authorization header provided` +### Die Abfrage liefert `Authentication error: no authorization header provided` -The HTTP API requires basic auth matching the `[[query.users]]` entry, e.g. `-u databend:` with `auth_type = "no_password"`. +Die HTTP-API verlangt Basic Auth passend zum Eintrag `[[query.users]]`, zum Beispiel `-u databend:` bei `auth_type = "no_password"`. -### `Unknown table` right after CREATE succeeded +### `Unknown table` direkt nach erfolgreichem CREATE -Double-quoted strings in SQL are identifiers, not literals. Use single quotes for VALUES and for the CONNECTION/LOCATION options. +Doppelt zitierte Zeichenketten in SQL sind Bezeichner, keine Literale. Verwenden Sie einfache Anführungszeichen für VALUES und für die Optionen CONNECTION und LOCATION. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Databend storage options. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Databend documentation](https://docs.databend.com/) for multi-node clusters and share tables on top of the same bucket. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Databend-Speicheroptionen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Databend-Dokumentation](https://docs.databend.com/) für Cluster mit mehreren Knoten und Share-Tabellen auf demselben Bucket. diff --git a/content/de/developer/integration/database/doris.md b/content/de/developer/integration/database/doris.md index 1c3665b5c..1ceae5c5b 100644 --- a/content/de/developer/integration/database/doris.md +++ b/content/de/developer/integration/database/doris.md @@ -1,13 +1,13 @@ --- title: "Apache Doris" -description: "Back up Apache Doris tables to RustFS through an S3 repository and restore them." +description: "Sichern Sie Apache-Doris-Tabellen über ein S3-Repository nach RustFS und stellen Sie sie wieder her." --- -This guide connects [Apache Doris](https://github.com/apache/doris) — the real-time analytical data warehouse — to **RustFS** through an S3 backup repository. You will start an all-in-one Doris container, create an S3 repository pointing at a RustFS bucket, back up a table, drop it, and restore it from RustFS. The workflow was verified with `apache/doris:all-in-one-4.1.3` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache Doris](https://github.com/apache/doris) — das analytische Data Warehouse für Echtzeit — über ein S3-Backup-Repository mit **RustFS**. Sie starten einen All-in-one-Container von Doris, legen ein S3-Repository an, das auf einen RustFS-Bucket zeigt, sichern eine Tabelle, löschen sie und stellen sie aus RustFS wieder her. Der Ablauf wurde mit `apache/doris:all-in-one-4.1.3` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,27 +15,27 @@ flowchart LR Doris -->|"BACKUP / RESTORE"| RustFS["RustFS :9000"] ``` -The repository is a named S3 location under the `doris-backups` bucket. `BACKUP SNAPSHOT` uploads table metadata and tablet data files; `RESTORE SNAPSHOT` downloads them into a new table. +Das Repository ist ein benannter S3-Speicherort unter dem Bucket `doris-backups`. `BACKUP SNAPSHOT` lädt Tabellenmetadaten und Tablet-Datendateien hoch. `RESTORE SNAPSHOT` lädt sie in eine neue Tabelle herunter. -## 1. Start Doris and create the repository +## 1. Doris starten und das Repository anlegen -Create the bucket first — Doris does not create buckets: +Legen Sie zuerst den Bucket an. Doris legt keine Buckets an: ```bash rc alias set rustfs http://:9000 rc mb rustfs/doris-backups ``` -Start the all-in-one container on the same Docker network as RustFS: +Starten Sie den All-in-one-Container im selben Docker-Netzwerk wie RustFS: ```bash docker run -d --name doris --network oo-rustfs_default \ -p 8030:8030 -p 9030:9030 apache/doris:all-in-one-4.1.3 ``` -Wait for the frontend to become healthy, then connect with the MySQL protocol (port 9030, user `root`, no password in the all-in-one image). +Warten Sie, bis das Frontend gesund ist, und verbinden Sie sich dann über das MySQL-Protokoll (Port 9030, Benutzer `root`, im All-in-one-Image ohne Passwort). -Create a test table with rows: +Legen Sie eine Testtabelle mit Zeilen an: ```sql CREATE DATABASE rustfs_demo; @@ -46,7 +46,7 @@ CREATE TABLE rustfs_demo.events INSERT INTO rustfs_demo.events VALUES (1, 'doris-on-rustfs'), (2, 'backup-test'); ``` -Create the S3 repository, replacing the endpoint with the IP address of the RustFS container and both credential placeholders: +Legen Sie das S3-Repository an, ersetzen Sie den Endpunkt durch die IP-Adresse des RustFS-Containers und beide Platzhalter für die Zugangsdaten: ```sql CREATE REPOSITORY `rustfs_repo` @@ -61,11 +61,11 @@ CREATE REPOSITORY `rustfs_repo` ); ``` -Doris 4.1 resolves the bucket into the endpoint hostname even with `AWS_PATH_STYLE_ACCESS` enabled, so a hostname endpoint fails with `UnknownHostException: doris-backups.rustfs`. Using the container IP address forces path-style requests and works; `SHOW REPOSITORIES` confirms the repository registered with an empty `ErrMsg`. +Doris 4.1 setzt den Bucket auch bei aktiviertem `AWS_PATH_STYLE_ACCESS` in den Hostnamen des Endpunkts ein, daher scheitert ein Hostname-Endpunkt mit `UnknownHostException: doris-backups.rustfs`. Die IP-Adresse des Containers erzwingt Anfragen mit pfadbasierter Adressierung (Path-Style) und funktioniert. `SHOW REPOSITORIES` bestätigt, dass das Repository mit leerem `ErrMsg` registriert wurde. -## 2. Back up a table to RustFS +## 2. Eine Tabelle nach RustFS sichern -Take a snapshot of the table: +Erstellen Sie einen Snapshot der Tabelle: ```sql BACKUP SNAPSHOT rustfs_demo.demo_snapshot @@ -73,23 +73,23 @@ BACKUP SNAPSHOT rustfs_demo.demo_snapshot ON (events); ``` -The statement returns immediately; the backup job runs in the background. Watch its state: +Die Anweisung kehrt sofort zurück. Der Backup-Job läuft im Hintergrund. Beobachten Sie seinen Status: ```sql SHOW BACKUP; ``` -Wait until `State` reaches `FINISHED` — the snapshot metadata and tablet data files are now objects in the bucket. +Warten Sie, bis `State` den Wert `FINISHED` erreicht. Die Snapshot-Metadaten und die Tablet-Datendateien sind dann Objekte im Bucket. -## 3. Verify the backup in RustFS +## 3. Das Backup in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/doris-backups/ -r ``` -The repository stores a repository descriptor, the snapshot metadata, and the tablet files: +Das Repository speichert einen Repository-Deskriptor, die Snapshot-Metadaten und die Tablet-Dateien: ```text rustfs-repo/__palo_repository_rustfs_repo/__repo_info @@ -97,11 +97,11 @@ rustfs-repo/__palo_repository_rustfs_repo/__ss_demo_snapshot/__meta.d50ecf9b... rustfs-repo/__palo_repository_rustfs_repo/__ss_demo_snapshot/__ss_content/.../...dat... ``` -![Doris backup objects stored in the RustFS Console](./images/rustfs-doris-backup.png) +![In der RustFS-Console gespeicherte Doris-Backup-Objekte](./images/rustfs-doris-backup.png) -## 4. Restore the table from RustFS +## 4. Die Tabelle aus RustFS wiederherstellen -Drop the table and restore it from the snapshot. The timestamp comes from the snapshot name shown by `SHOW SNAPSHOT ON REPOSITORY rustfs_repo;`: +Löschen Sie die Tabelle und stellen Sie sie aus dem Snapshot wieder her. Der Zeitstempel stammt aus dem Snapshot-Namen, den `SHOW SNAPSHOT ON REPOSITORY rustfs_repo;` anzeigt: ```sql DROP TABLE rustfs_demo.events; @@ -115,7 +115,7 @@ RESTORE SNAPSHOT rustfs_demo.demo_snapshot ); ``` -Wait for the restore job to finish and confirm the data: +Warten Sie, bis der Restore-Job abgeschlossen ist, und bestätigen Sie die Daten: ```sql SHOW RESTORE; @@ -126,36 +126,36 @@ SELECT count(*) FROM rustfs_demo.events; 2 ``` -## 5. Stop or reset the deployment +## 5. Die Bereitstellung stoppen oder zurücksetzen -Stop Doris while keeping the data: +Stoppen Sie Doris und behalten Sie die Daten: ```bash docker rm -f doris ``` -The backup stays in the `doris-backups` bucket and can be restored into any Doris cluster that registers the same repository. To delete it, remove the bucket: +Das Backup bleibt im Bucket `doris-backups` und lässt sich in jedem Doris-Cluster wiederherstellen, der dasselbe Repository registriert. Um es zu löschen, entfernen Sie den Bucket: ```bash rc rb rustfs/doris-backups --force ``` -## Troubleshooting +## Fehlerbehebung -### `UnknownHostException: doris-backups.rustfs` when creating the repository +### `UnknownHostException: doris-backups.rustfs` beim Anlegen des Repositorys -Doris is building a virtual-hosted hostname from the bucket and endpoint. Use the RustFS container IP address in `AWS_ENDPOINT` together with `AWS_PATH_STYLE_ACCESS = "true"`, as shown above. +Doris baut aus Bucket und Endpunkt einen Hostnamen für die Adressierung im Virtual-Hosted-Stil. Verwenden Sie die IP-Adresse des RustFS-Containers in `AWS_ENDPOINT` zusammen mit `AWS_PATH_STYLE_ACCESS = "true"`, wie oben gezeigt. -### The backup stays in `SNAPSHOTING` for a long time +### Das Backup bleibt lange in `SNAPSHOTING` -The backend uploads the tablet files. Confirm the backend is healthy (`SHOW BACKENDS;`) and can reach the endpoint; the all-in-one image needs a minute or two after start before both processes report ready. +Das Backend lädt die Tablet-Dateien hoch. Prüfen Sie, dass das Backend gesund ist (`SHOW BACKENDS;`) und den Endpunkt erreichen kann. Das All-in-one-Image braucht nach dem Start ein bis zwei Minuten, bis beide Prozesse Bereitschaft melden. ### `Failed to create repository: ... file status` -The bucket does not exist or the credentials are wrong. Create `doris-backups` with `rc mb` and re-check the access key pair. +Der Bucket existiert nicht oder die Zugangsdaten sind falsch. Legen Sie `doris-backups` mit `rc mb` an und prüfen Sie das Zugriffsschlüssel-Paar erneut. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Doris operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Doris backup and restore documentation](https://doris.apache.org/docs/data-operate/backup-restore/) to schedule periodic snapshots. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Doris-Operationen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Doris-Dokumentation zu Backup und Restore](https://doris.apache.org/docs/data-operate/backup-restore/), um periodische Snapshots zu planen. diff --git a/content/de/developer/integration/database/duckdb.md b/content/de/developer/integration/database/duckdb.md index 2e80c91ff..3b78631f8 100644 --- a/content/de/developer/integration/database/duckdb.md +++ b/content/de/developer/integration/database/duckdb.md @@ -116,7 +116,7 @@ docker compose up -d docker compose ps -a ``` -Der Dienst `create-bucket` sollte mit dem Exit-Code `0` enden. Die RustFS-Konsole erreichen Sie jederzeit unter `http://localhost:9001/rustfs/console/`. +Der Dienst `create-bucket` sollte mit dem Exit-Code `0` enden. Die RustFS Console erreichen Sie jederzeit unter `http://localhost:9001/rustfs/console/`. ## 3. Das S3-Secret in DuckDB konfigurieren @@ -197,9 +197,9 @@ docker compose run --rm --entrypoint /bin/sh create-bucket -c \ [2026-09-20 06:52:45] 5.32 KiB duckdb-demo/events.parquet ``` -Sie können das Präfix `duckdb-demo` auch in der RustFS-Konsole anzeigen: +Sie können das Präfix `duckdb-demo` auch in der RustFS Console anzeigen: -![Das Präfix duckdb-demo in der RustFS-Konsole](./images/rustfs-duckdb-objects.png) +![Das Präfix duckdb-demo in der RustFS Console](./images/rustfs-duckdb-objects.png) ## 7. Stack stoppen oder zurücksetzen @@ -239,6 +239,6 @@ docker compose logs create-bucket ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [DuckDB-httpfs-Dokumentation](https://duckdb.org/docs/stable/extensions/httpfs/overview) für erweiterte Optionen wie Regions-Overrides und Verbindungslimits. diff --git a/content/de/developer/integration/database/index.md b/content/de/developer/integration/database/index.md index 53e1550a6..16917fbd4 100644 --- a/content/de/developer/integration/database/index.md +++ b/content/de/developer/integration/database/index.md @@ -1,11 +1,11 @@ --- -title: "Database" -description: "Connect databases to RustFS through S3-compatible object storage interfaces." +title: "Datenbank" +description: "Verbinden Sie Datenbanken über S3-kompatible Objektspeicher-Schnittstellen mit RustFS." --- -Use **RustFS** as the object storage layer for databases that support an S3-compatible endpoint. +Nutzen Sie **RustFS** als Objektspeicher-Backend für Datenbanken mit S3-kompatiblem Endpunkt. -## Databases +## Datenbanken - [ClickHouse](./clickhouse.md) - [Doris](./doris.md) @@ -17,4 +17,4 @@ Use **RustFS** as the object storage layer for databases that support an S3-comp - [Databend](./databend.md) - [Vitess](./vitess.md) -Keep database data and backups in a dedicated bucket and prefix, and use credentials scoped to the required bucket operations. +Halten Sie Datenbankdaten und Sicherungen in einem eigenen Bucket und unter einem eigenen Präfix und verwenden Sie Zugangsdaten, die auf die erforderlichen Bucket-Operationen beschränkt sind. diff --git a/content/de/developer/integration/database/influxdb.md b/content/de/developer/integration/database/influxdb.md index a21a3025a..3af71e773 100644 --- a/content/de/developer/integration/database/influxdb.md +++ b/content/de/developer/integration/database/influxdb.md @@ -213,9 +213,9 @@ Katalog, Write-Ahead-Log und später die Parquet-Datendateien liegen unter dem K [2026-09-20 23:20:19] 31 B influxdb-demo/table-index-conversion-completed ``` -Sie können das Präfix auch in der RustFS-Konsole anzeigen: +Sie können das Präfix auch in der RustFS Console anzeigen: -![Das InfluxDB-Knoten-Präfix in der RustFS-Konsole](./images/rustfs-influxdb-objects.png) +![Das InfluxDB-Knoten-Präfix in der RustFS Console](./images/rustfs-influxdb-objects.png) ## 7. Persistenz über einen Neustart bestätigen @@ -274,6 +274,6 @@ docker compose logs create-bucket ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [InfluxDB-3-Core-Dokumentation](https://docs.influxdata.com/influxdb3/core/), um Telegraf oder die Write-APIs als Datenproduzenten anzubinden. diff --git a/content/de/developer/integration/database/lancedb.md b/content/de/developer/integration/database/lancedb.md index 38a0703ab..71d772c7a 100644 --- a/content/de/developer/integration/database/lancedb.md +++ b/content/de/developer/integration/database/lancedb.md @@ -1,13 +1,13 @@ --- title: "LanceDB" -description: "Store and query LanceDB vector tables directly on RustFS." +description: "Speichern und fragen Sie LanceDB-Vektortabellen direkt auf RustFS ab." --- -This guide connects [LanceDB](https://github.com/lancedb/lancedb) — the open-source vector database built on the Lance columnar format — to **RustFS** as its storage backend. You will create a vector table directly at an `s3://` location, add rows, run a vector search, and confirm the Lance table files in the bucket. The workflow was verified with the `lancedb` Python package against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [LanceDB](https://github.com/lancedb/lancedb) — die quelloffene Vektordatenbank auf dem spaltenorientierten Format Lance — mit **RustFS** als Speicher-Backend. Sie legen eine Vektortabelle direkt an einem Speicherort `s3://` an, fügen Zeilen hinzu, führen eine Vektorsuche aus und prüfen die Lance-Tabellendateien im Bucket. Der Ablauf wurde mit dem Python-Paket `lancedb` gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Python 3.9 or newer. This deployment is intended for local integration testing, not production. +Sie benötigen Python 3.9 oder neuer. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,17 +15,17 @@ flowchart LR LanceDB -->|"Lance fragments + manifests"| RustFS["RustFS :9000"] ``` -LanceDB is embedded: there is no server to run. The Python (or Rust, or JavaScript) client talks to the bucket directly, storing each table as a `*.lance` directory with data fragments, version manifests, and transaction logs. +LanceDB ist eingebettet: es gibt keinen Server, den Sie starten müssten. Der Client in Python, Rust oder JavaScript spricht den Bucket direkt an und speichert jede Tabelle als Verzeichnis `*.lance` mit Datenfragmenten, Versionsmanifesten und Transaktionsprotokollen. -## 1. Install the client +## 1. Den Client installieren ```bash pip install lancedb ``` -## 2. Create a table on RustFS +## 2. Eine Tabelle auf RustFS anlegen -Connect straight to the bucket and create a table, replacing all connection placeholders. The `storage_options` keys follow Lance's object-store conventions; custom endpoints use path-style addressing: +Verbinden Sie sich direkt mit dem Bucket und legen Sie eine Tabelle an. Ersetzen Sie alle Verbindungsplatzhalter. Die Schlüssel in `storage_options` folgen den Object-Store-Konventionen von Lance. Eigene Endpunkte verwenden pfadbasierte Adressierung (Path-Style): ```python title="lance_s3.py" import lancedb @@ -54,9 +54,9 @@ created: 5 rows after add: 6 rows ``` -The table URI uses the `s3://bucket/prefix` form; every write and read goes to RustFS over its S3 API. +Die Tabellen-URI verwendet die Form `s3://bucket/prefix`. Jeder Schreib- und Lesevorgang geht über die S3-API nach RustFS. -## 3. Run a vector search +## 3. Eine Vektorsuche ausführen ```python title="lance_search.py" import lancedb @@ -74,17 +74,17 @@ top3: [(99, 'query-target'), (4, 'row-4'), (3, 'row-3')] version: 2 ``` -The nearest neighbor is the row added in the previous step, and the version counter reflects the two commits (create and add). +Der nächste Nachbar ist die Zeile aus dem vorherigen Schritt, und der Versionszähler spiegelt die beiden Commits (Anlegen und Hinzufügen). -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen -List the table prefix: +Listen Sie das Tabellenpräfix auf: ```bash rc ls rustfs// -r ``` -Each table is a `.lance` directory holding data fragments, version manifests, and transaction records: +Jede Tabelle ist ein Verzeichnis `.lance` mit Datenfragmenten, Versionsmanifesten und Transaktionsdatensätzen: ```text tables/events.lance/_transactions/0-b93cf795-fc3d-4bc9-88c8-e37baeefdd46.txn @@ -92,34 +92,34 @@ tables/events.lance/_versions/18446744073709551613.manifest tables/events.lance/data/101101011110110010000100e7a149411b847dbad6ebc7d47e.lance ``` -Multiple tables share the bucket under the `tables/` prefix, so one bucket can back an entire LanceDB workspace. +Mehrere Tabellen teilen sich den Bucket unter dem Präfix `tables/`, daher kann ein Bucket einen gesamten LanceDB-Workspace tragen. -![LanceDB table files stored in the RustFS Console](./images/rustfs-lancedb-table.png) +![In der RustFS-Console gespeicherte LanceDB-Tabellendateien](./images/rustfs-lancedb-table.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -LanceDB holds no server state. To delete the table: +LanceDB hält keinen Serverzustand. So löschen Sie die Tabelle: ```bash rc rm rustfs//tables/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### Connection or signature errors on first use +### Verbindungs- oder Signaturfehler bei der ersten Verwendung -Confirm `endpoint` includes the scheme, `allow_http` is `"true"` for plain-HTTP endpoints, and the bucket exists. The `region` value is required by the S3 signer even though RustFS ignores it. +Prüfen Sie, dass `endpoint` das Schema enthält, dass `allow_http` für Endpunkte mit unverschlüsseltem HTTP auf `"true"` steht und dass der Bucket existiert. Der Wert `region` ist für den S3-Signer erforderlich, auch wenn RustFS ihn ignoriert. -### `Table not found` after creating it +### `Table not found` nach dem Anlegen -LanceDB lists the bucket prefix to discover tables. A stale client cache or a wrong `tables/` prefix in the URI makes new tables invisible; reconnect with the same URI used at creation time. +LanceDB listet das Bucket-Präfix auf, um Tabellen zu finden. Ein veralteter Client-Cache oder ein falsches Präfix `tables/` in der URI macht neue Tabellen unsichtbar. Verbinden Sie sich erneut mit derselben URI, die Sie beim Anlegen verwendet haben. -### Slow bulk loads over the network +### Langsame Massenladungen über das Netzwerk -Lance writes one fragment per commit. For large imports, batch rows into fewer `table.add` calls — each call produces a new data file in the bucket. +Lance schreibt ein Fragment je Commit. Fassen Sie bei großen Importen Zeilen in weniger Aufrufen von `table.add` zusammen. Jeder Aufruf erzeugt eine neue Datendatei im Bucket. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional LanceDB storage options. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [LanceDB documentation](https://lancedb.github.io/lancedb/) for ANN indexes, hybrid search, and multi-tenant bucket layouts on top of the same backend. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere LanceDB-Speicheroptionen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [LanceDB-Dokumentation](https://lancedb.github.io/lancedb/) für ANN-Indizes, hybride Suche und Bucket-Layouts für mehrere Tenants auf demselben Backend. diff --git a/content/de/developer/integration/database/meta.json b/content/de/developer/integration/database/meta.json index cbf3ed7b8..f9323b370 100644 --- a/content/de/developer/integration/database/meta.json +++ b/content/de/developer/integration/database/meta.json @@ -1,5 +1,5 @@ { - "title": "Database", + "title": "Datenbank", "pages": [ "clickhouse", "doris", diff --git a/content/de/developer/integration/database/milvus.md b/content/de/developer/integration/database/milvus.md index 2b17701bf..fa8654b70 100644 --- a/content/de/developer/integration/database/milvus.md +++ b/content/de/developer/integration/database/milvus.md @@ -1,19 +1,19 @@ --- title: "Milvus" -description: "Run Milvus with RustFS as its S3-compatible object storage backend using Docker Compose." +description: "Betreiben Sie Milvus mit RustFS als S3-kompatiblem Objektspeicher-Backend mit Docker Compose." --- -This guide runs **Milvus Standalone** with **RustFS** as its S3-compatible object storage backend. You will start Milvus, etcd, RustFS, and Attu; insert sample vectors; and verify that Milvus persists objects in RustFS. +In dieser Anleitung betreiben Sie **Milvus Standalone** mit **RustFS** als S3-kompatiblem Objektspeicher-Backend. Sie starten Milvus, etcd, RustFS und Attu, fügen Beispielvektoren ein und prüfen, dass Milvus Objekte in RustFS persistiert. -You need Docker with the Compose plugin and Python 3.9 or later. This deployment is intended for local integration testing, not production. +Sie benötigen Docker mit dem Compose-Plugin und Python 3.9 oder neuer. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -:::note[Milvus configuration names] +:::note[Namen der Milvus-Konfiguration] -Milvus groups S3-compatible storage settings under the `minio` configuration key. The name does not require a MinIO server. In this guide, `minio.address` points to the RustFS service, and Milvus uses the S3 API exposed by RustFS. +Milvus fasst Einstellungen für S3-kompatiblen Speicher unter dem Konfigurationsschlüssel `minio` zusammen. Der Name verlangt keinen MinIO-Server. In dieser Anleitung zeigt `minio.address` auf den Dienst RustFS, und Milvus verwendet die von RustFS bereitgestellte S3-API. ::: -## Architecture +## Architektur ```mermaid flowchart LR @@ -24,27 +24,27 @@ flowchart LR Init["Bucket initializer"] -->|Create my-bucket| RustFS ``` -Milvus stores service metadata in etcd and persists vector data, indexes, and related objects under `s3://my-bucket/milvus` in RustFS. The local Milvus volume remains necessary for runtime data and caches. +Milvus speichert Dienstmetadaten in etcd und persistiert Vektordaten, Indizes und zugehörige Objekte unter `s3://my-bucket/milvus` in RustFS. Das lokale Milvus-Volume bleibt für Laufzeitdaten und Caches erforderlich. -## 1. Create the project files +## 1. Projektdateien anlegen -Create a working directory: +Erstellen Sie ein Arbeitsverzeichnis: ```bash mkdir rustfs-milvus cd rustfs-milvus ``` -Create an environment file and replace both credential placeholders: +Erstellen Sie eine Umgebungsdatei und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Use dedicated credentials for the Milvus bucket. Do not commit `.env` to source control. +Verwenden Sie dedizierte Zugangsdaten für den Milvus-Bucket. Nehmen Sie `.env` nicht in die Versionsverwaltung auf. -Create the Milvus storage override: +Legen Sie die Speicherüberschreibung für Milvus an: ```yaml title="user.yaml" common: @@ -62,9 +62,9 @@ minio: useVirtualHost: false ``` -`useVirtualHost: false` selects path-style S3 requests. The hostname `rustfs` resolves inside the Compose network; clients on the host use `http://localhost:9000`. +`useVirtualHost: false` wählt S3-Anfragen mit pfadbasierter Adressierung (Path-Style). Der Hostname `rustfs` wird innerhalb des Compose-Netzwerks aufgelöst. Clients auf dem Host verwenden `http://localhost:9000`. -Create the Compose file: +Legen Sie die Compose-Datei an: ```yaml title="compose.yaml" services: @@ -186,46 +186,46 @@ volumes: milvus-data: ``` -The `create-bucket` service uses the official [`rc`](https://github.com/rustfs/cli) image and exits after ensuring that `my-bucket` exists. Named volumes preserve etcd metadata, RustFS objects, and Milvus local data when containers are recreated. +Der Dienst `create-bucket` verwendet das offizielle Image [`rc`](https://github.com/rustfs/cli) und beendet sich, nachdem sichergestellt ist, dass `my-bucket` existiert. Benannte Volumes behalten etcd-Metadaten, RustFS-Objekte und lokale Milvus-Daten, wenn Container neu erstellt werden. -:::warning[Protect local service ports] +:::warning[Lokale Dienstports schützen] -The Compose file publishes the RustFS API and Console, Milvus gRPC and health ports, and Attu on the host for local testing. Do not expose these ports to an untrusted network. Production deployments require scoped credentials, TLS, authentication, resource planning, backups, and independently operated dependencies. +Die Compose-Datei veröffentlicht die RustFS-API und die Console, die gRPC- und Integritätsports von Milvus sowie Attu auf dem Host für lokale Tests. Stellen Sie diese Ports keinem nicht vertrauenswürdigen Netzwerk bereit. Produktivbereitstellungen brauchen eingeschränkte Zugangsdaten, TLS, Authentifizierung, Ressourcenplanung, Sicherungen und unabhängig betriebene Abhängigkeiten. ::: -## 2. Validate and start the deployment +## 2. Die Bereitstellung prüfen und starten -Resolve the Compose file before starting containers: +Prüfen Sie die Compose-Datei, bevor Sie Container starten: ```bash docker compose config ``` -Start the services: +Starten Sie die Dienste: ```bash docker compose up -d docker compose ps -a ``` -The `create-bucket` service should exit with code `0`, and `etcd`, `rustfs`, and `standalone` should become healthy. Inspect logs if a service does not reach its expected state: +Der Dienst `create-bucket` sollte mit Code `0` enden, und `etcd`, `rustfs` sowie `standalone` sollten gesund werden. Prüfen Sie die Logs, wenn ein Dienst seinen erwarteten Zustand nicht erreicht: ```bash docker compose logs create-bucket rustfs standalone ``` -Open these local interfaces: +Öffnen Sie diese lokalen Oberflächen: -- RustFS Console: `http://localhost:9001` +- RustFS-Console: `http://localhost:9001` - Attu: `http://localhost:8000` -- Milvus health endpoint: `http://localhost:9091/healthz` +- Integritätsendpunkt von Milvus: `http://localhost:9091/healthz` -Attu connects to `standalone:19530` through the Compose network. If Attu asks for a connection address, use that service name instead of `localhost:19530`. +Attu verbindet sich über das Compose-Netzwerk mit `standalone:19530`. Wenn Attu nach einer Verbindungsadresse fragt, verwenden Sie diesen Dienstnamen statt `localhost:19530`. -## 3. Insert and query sample vectors +## 3. Beispielvektoren einfügen und abfragen -Create a Python virtual environment and install the Milvus client version that matches the server release: +Legen Sie eine Python-Virtualenv an und installieren Sie die Milvus-Client-Version, die zum Server-Release passt: ```bash python3 -m venv .venv @@ -233,7 +233,7 @@ source .venv/bin/activate python -m pip install "pymilvus==2.6.0" ``` -Create a test script: +Legen Sie ein Testskript an: ```python title="verify_milvus.py" from pymilvus import MilvusClient @@ -270,85 +270,85 @@ print(results) client.close() ``` -Run the script: +Führen Sie das Skript aus: ```bash python verify_milvus.py ``` -The result should rank the row with ID `1` first. Open Attu and confirm that the `rustfs_demo` collection contains three entities. +Das Ergebnis sollte die Zeile mit der ID `1` zuerst einstufen. Öffnen Sie Attu und bestätigen Sie, dass die Collection `rustfs_demo` drei Entitäten enthält. -## 4. Verify Milvus objects in RustFS +## 4. Milvus-Objekte in RustFS prüfen -Use the bucket-initializer image to list objects below the configured `milvus` root path: +Listen Sie mit dem Image der Bucket-Initialisierung die Objekte unter dem konfigurierten Wurzelpfad `milvus` auf: ```bash docker compose run --rm --entrypoint /bin/sh create-bucket -c \ '/usr/bin/rc alias set rustfs http://rustfs:9000 "$RUSTFS_ACCESS_KEY" "$RUSTFS_SECRET_KEY" --region us-east-1 --bucket-lookup path >/dev/null && /usr/bin/rc find rustfs/my-bucket/milvus' ``` -The output should contain objects created by Milvus below the `milvus/` prefix. You can also open `my-bucket` in the RustFS Console. +Die Ausgabe sollte Objekte enthalten, die Milvus unter dem Präfix `milvus/` angelegt hat. Sie können `my-bucket` auch in der RustFS-Console öffnen. -Milvus may buffer or compact data before every expected object appears. The successful insert, flush, query, and RustFS object listing together validate the integration path. +Milvus kann Daten puffern oder kompaktieren, bevor jedes erwartete Objekt erscheint. Das erfolgreiche Einfügen, der Flush, die Abfrage und die Objektliste in RustFS validieren gemeinsam den Integrationspfad. -## 5. Stop or reset the stack +## 5. Den Stack stoppen oder zurücksetzen -Stop the containers while retaining all named volumes: +Stoppen Sie die Container und behalten Sie alle benannten Volumes: ```bash docker compose down ``` -To delete the local test data, including the Milvus bucket contents and etcd metadata, explicitly remove the volumes: +Um die lokalen Testdaten zu löschen, einschließlich des Inhalts des Milvus-Buckets und der etcd-Metadaten, entfernen Sie die Volumes ausdrücklich: ```bash docker compose down --volumes ``` -:::warning[Reset removes the test data] +:::warning[Zurücksetzen löscht die Testdaten] -The `--volumes` option permanently deletes the named volumes used by this Compose project. Do not run it against data you need to retain. +Die Option `--volumes` löscht die benannten Volumes dieses Compose-Projekts dauerhaft. Führen Sie sie nicht für Daten aus, die Sie behalten müssen. ::: -## Troubleshooting +## Fehlerbehebung -### Milvus cannot reach RustFS +### Milvus erreicht RustFS nicht -Use `rustfs:9000` as the S3 endpoint inside Compose. `localhost:9000` inside the Milvus container refers to that container, not RustFS. +Verwenden Sie `rustfs:9000` als S3-Endpunkt innerhalb von Compose. `localhost:9000` im Milvus-Container meint diesen Container, nicht RustFS. -Confirm that `useVirtualHost` remains `false` and that the credential values passed to Milvus match the RustFS credentials: +Prüfen Sie, dass `useVirtualHost` auf `false` bleibt und dass die an Milvus übergebenen Zugangsdaten zu den RustFS-Zugangsdaten passen: ```bash docker compose logs standalone rustfs ``` -### The bucket initializer fails +### Die Bucket-Initialisierung schlägt fehl -Check RustFS readiness and the initializer logs: +Prüfen Sie die Bereitschaft von RustFS und die Logs der Initialisierung: ```bash curl -fsS http://localhost:9000/health/ready docker compose logs create-bucket ``` -Verify that `.env` contains non-empty credentials and that `docker compose config` resolves both variables. +Prüfen Sie, dass `.env` nicht leere Zugangsdaten enthält und dass `docker compose config` beide Variablen auflöst. -### Milvus starts without existing data +### Milvus startet ohne vorhandene Daten -Do not change `minio.bucketName`, `minio.rootPath`, or the etcd root for an existing deployment. Confirm that the `rustfs-data`, `etcd-data`, and `milvus-data` volumes still exist and that the same Compose project name is in use. +Ändern Sie `minio.bucketName`, `minio.rootPath` oder die etcd-Wurzel einer vorhandenen Bereitstellung nicht. Prüfen Sie, dass die Volumes `rustfs-data`, `etcd-data` und `milvus-data` noch existieren und dass derselbe Name des Compose-Projekts verwendet wird. -### Attu cannot connect +### Attu kann sich nicht verbinden -The Attu container must use `standalone:19530`. A browser or host-side client uses `localhost:19530`. Check Milvus health and Attu logs: +Der Attu-Container muss `standalone:19530` verwenden. Ein Browser oder ein Client auf dem Host verwendet `localhost:19530`. Prüfen Sie die Integrität von Milvus und die Attu-Logs: ```bash curl -fsS http://localhost:9091/healthz docker compose logs attu standalone ``` -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before enabling additional Milvus storage features. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Milvus documentation](https://milvus.io/docs) when adapting this local pattern to a managed or distributed deployment. \ No newline at end of file +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Milvus-Speicherfunktionen aktivieren. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Milvus-Dokumentation](https://milvus.io/docs), wenn Sie dieses lokale Muster auf eine verwaltete oder verteilte Bereitstellung übertragen. diff --git a/content/de/developer/integration/database/trino.md b/content/de/developer/integration/database/trino.md index 6a3565c3b..0553cdca1 100644 --- a/content/de/developer/integration/database/trino.md +++ b/content/de/developer/integration/database/trino.md @@ -197,13 +197,13 @@ docker compose run --rm --entrypoint /bin/sh create-bucket -c \ [2026-09-21 01:55:25] 432 B trino-metastore/demo/events/20260921_..._cb761cec-...parquet ``` -Sie können das Präfix auch in der RustFS-Konsole anzeigen: +Sie können das Präfix auch in der RustFS Console anzeigen: -![Die Trino-Metadaten- und Datenobjekte in der RustFS-Konsole](./images/rustfs-trino-objects.png) +![Die Trino-Metadaten- und Datenobjekte in der RustFS Console](./images/rustfs-trino-objects.png) ## 6. RustFS S3 Tables verwenden -RustFS S3 Tables bietet einen integrierten Apache-Iceberg-REST-Katalog, sodass Trino einen Tabellen-Bucket als verwaltetes Iceberg-Warehouse nutzen kann, während die Daten in RustFS bleiben. Aktivieren Sie einen Tabellen-Bucket und verbinden Sie den Iceberg-Connector von Trino mit dem REST-Katalog, wie in [S3 Tables](/administration/data/s3-tables) beschrieben: Die REST-Katalog-URI ist `http://:9000/iceberg`, das Warehouse ist der Bucket-Name, und sowohl Kataloganfragen (AWS Signature Version 4, Signing-Name `s3`) als auch der S3-Dateizugriff verwenden pfadbasierte Adressierung (Path-Style). +RustFS S3 Tables bietet einen integrierten Apache-Iceberg-REST-Katalog, sodass Trino einen Tabellen-Bucket als verwaltetes Iceberg-Warehouse nutzen kann, während die Daten in RustFS bleiben. Aktivieren Sie einen Tabellen-Bucket und verbinden Sie den Iceberg-Connector von Trino mit dem REST-Katalog, wie in [S3 Tables](/de/administration/data/s3-tables) beschrieben: Die REST-Katalog-URI ist `http://:9000/iceberg`, das Warehouse ist der Bucket-Name, und sowohl Kataloganfragen (AWS Signature Version 4, Signing-Name `s3`) als auch der S3-Dateizugriff verwenden pfadbasierte Adressierung (Path-Style). Laut der S3-Tables-Support-Matrix wurde Trino nur als Read-only-Probe gegen den Katalog geprüft; validieren Sie die Schreibkompatibilität und die exakte Trino-Version Ihrer Bereitstellung, bevor Sie diesen Pfad in Produktion übernehmen. @@ -231,7 +231,7 @@ Der Property-Name des nativen S3-Dateisystems hat sich zwischen Trino-Versionen Mit dem File-Metastore müssen Tabellen-Locations unter `hive.metastore.catalog.dir` bleiben. Erstellen Sie das Schema ohne explizite Location, oder zeigen Sie die Schema-Location auf ein Verzeichnis innerhalb desselben Bucket-Präfixes. -### Hive CSV storage format only supports VARCHAR +### Das CSV-Speicherformat von Hive unterstützt nur VARCHAR Das CSV-Format lehnt Nicht-String-Spalten ab. Verwenden Sie für typisierte Tabellen `format = 'parquet'` wie in dieser Anleitung. @@ -245,6 +245,6 @@ docker compose logs create-bucket ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [Trino-Dokumentation](https://trino.io/docs/current/), um BI-Tools anzubinden und weitere Objektspeicher-Kataloge hinzuzufügen. diff --git a/content/de/developer/integration/database/vitess.md b/content/de/developer/integration/database/vitess.md index 2260b7449..172c974f7 100644 --- a/content/de/developer/integration/database/vitess.md +++ b/content/de/developer/integration/database/vitess.md @@ -1,13 +1,13 @@ --- title: "Vitess" -description: "Back up Vitess to RustFS through the S3 backup storage implementation." +description: "Sichern Sie Vitess über die S3-Backup-Speicherimplementierung nach RustFS." --- -This guide connects [Vitess](https://github.com/vitessio/vitess) — the database clustering system for horizontal scaling of MySQL — to **RustFS** through Vitess's S3 backup storage implementation. You will bring up a minimal Vitess topology on a single host, run `Backup` on a tablet, and confirm the backup chunks and `MANIFEST` in the bucket, then read the backup list back from RustFS. The workflow was verified with `vitess/lite` (Vitess v25.0.0-SNAPSHOT, built 2026-09-22), MySQL 8.4, and `rustfs/rustfs-x86-musl:v2.3.1`; stable Vitess 20+ releases use the same flags. +In dieser Anleitung verbinden Sie [Vitess](https://github.com/vitessio/vitess) — das Datenbank-Clustering-System zur horizontalen Skalierung von MySQL — über die S3-Backup-Speicherimplementierung von Vitess mit **RustFS**. Sie bringen eine minimale Vitess-Topologie auf einem einzelnen Host hoch, führen `Backup` auf einem Tablet aus, prüfen die Backup-Chunks und `MANIFEST` im Bucket und lesen die Backup-Liste aus RustFS zurück. Der Ablauf wurde mit `vitess/lite` (Vitess v25.0.0-SNAPSHOT, gebaut am 2026-09-22), MySQL 8.4 und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. Stabile Releases von Vitess 20+ verwenden dieselben Flags. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,11 +16,11 @@ flowchart LR Tablet -->|"S3 API"| RustFS["RustFS :9000"] ``` -`vtctld` triggers the backup, but the `vttablet` owning the tablet performs it: it snapshots MySQL, compresses the data into numbered chunks, and uploads them together with a `MANIFEST` through the S3-compatible endpoint. +`vtctld` löst das Backup aus, ausgeführt wird es aber vom `vttablet`, dem das Tablet gehört: es erstellt einen Snapshot von MySQL, komprimiert die Daten in nummerierte Chunks und lädt sie zusammen mit einem `MANIFEST` über den S3-kompatiblen Endpunkt hoch. -## 1. Run etcd and the Vitess image +## 1. etcd und das Vitess-Image starten -Vitess stores its topology in etcd, and the `vitess/lite` image ships all Vitess binaries plus MySQL: +Vitess speichert seine Topologie in etcd, und das Image `vitess/lite` enthält alle Vitess-Binärdateien plus MySQL: ```bash docker run -d --name etcd --hostname etcd --network oo-rustfs_default \ @@ -34,26 +34,26 @@ docker run -d --name vtess --hostname vtess --network oo-rustfs_default \ vitess/lite:latest sleep infinity ``` -The AWS environment variables supply the credentials for the S3 backup storage in both `vtctld` and `vttablet`. +Die AWS-Umgebungsvariablen liefern die Zugangsdaten für den S3-Backup-Speicher in `vtctld` und `vttablet`. -## 2. Initialize MySQL +## 2. MySQL initialisieren -Initialize a MySQL instance in the standard Vitess tablet directory so `vttablet` can load its `my.cnf` later: +Initialisieren Sie eine MySQL-Instanz im üblichen Vitess-Tablet-Verzeichnis, damit `vttablet` später seine `my.cnf` laden kann: ```bash docker exec vtess sh -c \ "/vt/bin/mysqlctl --log_dir /tmp/vtlogs init --tablet-dir vt_0000000100" ``` -The instance is ready when the socket file exists: +Die Instanz ist bereit, wenn die Socket-Datei existiert: ```text /vt/vtdataroot/vt_0000000100/mysql.sock ``` -## 3. Start vtctld and vttablet +## 3. vtctld und vttablet starten -Start `vtctld` with the S3 backup flags, register the cell, and start the tablet. Replace all connection placeholders: +Starten Sie `vtctld` mit den S3-Backup-Flags, registrieren Sie die Cell und starten Sie das Tablet. Ersetzen Sie alle Verbindungsplatzhalter: ```bash docker exec vtess sh -c "nohup /vt/bin/vtctld \ @@ -95,7 +95,7 @@ docker exec vtess sh -c "nohup /vt/bin/vttablet \ --log_dir /tmp/vtlogs > /tmp/vtlogs/vttablet.out 2>&1 &" ``` -Both processes carry the S3 flags because `vttablet` performs the backup while `vtctld` lists and removes backups. `--s3-backup-force-path-style` is mandatory for non-AWS endpoints. Check that the tablet registered: +Beide Prozesse tragen die S3-Flags, weil `vttablet` das Backup ausführt, während `vtctld` Backups auflistet und entfernt. `--s3-backup-force-path-style` erzwingt pfadbasierte Adressierung (Path-Style) und ist für Endpunkte außerhalb von AWS zwingend. Prüfen Sie, dass das Tablet registriert wurde: ```bash docker exec vtess /vt/bin/vtctldclient --server localhost:15998 GetTablets @@ -105,9 +105,9 @@ docker exec vtess /vt/bin/vtctldclient --server localhost:15998 GetTablets zone1-0000000100 commerce 0 replica vtess:15100 vtess:3306 [] ``` -## 4. Run the backup +## 4. Das Backup ausführen -Create the bucket and trigger the backup: +Legen Sie den Bucket an und lösen Sie das Backup aus: ```bash rc mb rustfs/vitess-backups @@ -116,21 +116,21 @@ docker exec vtess /vt/bin/vtctldclient --server localhost:15998 \ Backup zone1-0000000100 ``` -The stream ends with the engine writing the manifest: +Der Stream endet damit, dass die Engine das Manifest schreibt: ```text commerce/0 (zone1-0000000100): ... value:"Completed backing up MANIFEST (attempt 1/2)" ``` -## 5. Verify objects in RustFS +## 5. Objekte in RustFS prüfen -List the backup prefix: +Listen Sie das Backup-Präfix auf: ```bash rc ls rustfs/vitess-backups/ -r | head -4 ``` -The tablet uploaded compressed data chunks plus the metadata files: +Das Tablet hat komprimierte Daten-Chunks plus die Metadatendateien hochgeladen: ```text commerce/commerce/0/2026-09-23.011225.zone1-0000000100/0 @@ -138,9 +138,9 @@ commerce/commerce/0/2026-09-23.011225.zone1-0000000100/1 commerce/commerce/0/2026-09-23.011225.zone1-0000000100/MANIFEST ``` -![Vitess backup files stored in the RustFS Console](./images/rustfs-vitess-backups.png) +![Vitess-Backup-Dateien in der RustFS-Console](./images/rustfs-vitess-backups.png) -Read the backup list back from RustFS through `vtctld`: +Lesen Sie die Backup-Liste über `vtctld` aus RustFS zurück: ```bash docker exec vtess /vt/bin/vtctldclient --server localhost:15998 GetBackups commerce/0 @@ -150,40 +150,40 @@ docker exec vtess /vt/bin/vtctldclient --server localhost:15998 GetBackups comme 2026-09-23.011225.zone1-0000000100 ``` -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen -To tear down the demo while keeping the bucket objects: +Um die Demo abzubauen und die Bucket-Objekte zu behalten: ```bash docker rm -f vtess etcd ``` -To delete the stored backups: +Um die gespeicherten Backups zu löschen: ```bash rc rm rustfs/vitess-backups/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `cannot perform backup without my.cnf` -Passing connection parameters such as `--db-socket` or `--db-host` makes `vttablet` skip loading `my.cnf`, and backups refuse to run. Start `vttablet` with `--mycnf-file` pointing at the instance config and let it discover the socket from there — this is why the MySQL instance lives in the `vt_0000000100` directory from step 2. +Wenn Sie Verbindungsparameter wie `--db-socket` oder `--db-host` übergeben, überspringt `vttablet` das Laden von `my.cnf`, und Backups verweigern die Ausführung. Starten Sie `vttablet` mit `--mycnf-file`, das auf die Instanzkonfiguration zeigt, und lassen Sie den Socket von dort ermitteln. Deshalb liegt die MySQL-Instanz aus Schritt 2 im Verzeichnis `vt_0000000100`. ### `unknown service vtctlservice.Vtctld` -`vtctld` exposes the API used by `vtctldclient` only when the service map includes it: `--service-map grpc-vtctl,grpc-vtctld`. Also make sure `vtctldclient --server` points at the gRPC port (`15998` here), not the web UI port. +`vtctld` stellt die von `vtctldclient` verwendete API nur bereit, wenn die Service-Map sie enthält: `--service-map grpc-vtctl,grpc-vtctld`. Stellen Sie außerdem sicher, dass `vtctldclient --server` auf den gRPC-Port zeigt (hier `15998`), nicht auf den Port der Weboberfläche. ### `node doesn't exist: /vitess/global/cells/zone1/CellInfo` -The cell must exist before tablets register. Run `vtctldclient AddCellInfo` as shown in step 3 before starting `vttablet`. +Die Cell muss existieren, bevor Tablets sich registrieren. Führen Sie `vtctldclient AddCellInfo` wie in Schritt 3 aus, bevor Sie `vttablet` starten. -### Flag parse errors such as `unknown shorthand flag` +### Flag-Parse-Fehler wie `unknown shorthand flag` -Vitess 20+ normalizes underscores to dashes, so write flags in dash style (`--tablet-path`). A single-dash long flag like `-tablet_dir` is parsed as shorthand options and fails. +Vitess 20+ normalisiert Unterstriche zu Bindestrichen, schreiben Sie Flags daher im Bindestrich-Stil (`--tablet-path`). Ein langes Flag mit einem einzelnen Bindestrich wie `-tablet_dir` wird als Kurzoptionen gelesen und schlägt fehl. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Vitess storage options. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Vitess backup and restore documentation](https://vitess.io/docs/user-guides/configuration-basic/#backups) to schedule backups and restore tablets from the bucket. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Vitess-Speicheroptionen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Vitess-Dokumentation zu Backup und Restore](https://vitess.io/docs/user-guides/configuration-basic/#backups), um Backups zu planen und Tablets aus dem Bucket wiederherzustellen. diff --git a/content/de/developer/integration/devops/elasticsearch.md b/content/de/developer/integration/devops/elasticsearch.md index 148211db6..f2b1f8bab 100644 --- a/content/de/developer/integration/devops/elasticsearch.md +++ b/content/de/developer/integration/devops/elasticsearch.md @@ -1,13 +1,13 @@ --- title: "Elasticsearch" -description: "Use RustFS as the S3 snapshot repository for Elasticsearch indices, deployed with Docker Compose." +description: "Verwenden Sie RustFS als S3-Snapshot-Repository für Elasticsearch-Indizes, bereitgestellt mit Docker Compose." --- -This guide connects [Elasticsearch](https://github.com/elastic/elasticsearch) — the distributed search and analytics engine — to **RustFS** as the S3 snapshot repository for its indices. You will start Elasticsearch with the `repository-s3` plugin, register a snapshot repository backed by RustFS, index documents, take a snapshot, and prove the full cycle by deleting the index and restoring it from RustFS. The workflow was verified with `docker.elastic.co/elasticsearch/elasticsearch:8.18.0` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Elasticsearch](https://github.com/elastic/elasticsearch) — die verteilte Such- und Analyse-Engine — mit **RustFS** als S3-Snapshot-Repository für die Indizes. Sie starten Elasticsearch mit dem Plugin `repository-s3`, registrieren ein auf RustFS gestütztes Snapshot-Repository, indexieren Dokumente, erstellen einen Snapshot und prüfen den gesamten Zyklus, indem Sie den Index löschen und ihn aus RustFS wiederherstellen. Der Ablauf wurde mit `docker.elastic.co/elasticsearch/elasticsearch:8.18.0` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker with the Compose plugin. This deployment is intended for local integration testing, not production. +Sie benötigen Docker mit dem Compose-Plugin. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,27 +16,27 @@ flowchart LR Init["init-bucket job"] -->|"create my-bucket"| RustFS ``` -Elasticsearch stores its primary data on local disks and offloads index backups to a snapshot repository. The `repository-s3` plugin writes snapshot metadata and shard data blobs to RustFS through the S3 API with path-style addressing over plain HTTP. +Elasticsearch speichert die Primärdaten auf lokalen Festplatten und lagert Index-Backups in ein Snapshot-Repository aus. Das Plugin `repository-s3` schreibt Snapshot-Metadaten und Shard-Daten-Blobs über die S3-API mit pfadbasierter Adressierung (Path-Style) und unverschlüsseltem HTTP nach RustFS. -## 1. Create the project files +## 1. Projektdateien anlegen -Create a working directory: +Erstellen Sie ein Arbeitsverzeichnis: ```bash mkdir rustfs-elasticsearch cd rustfs-elasticsearch ``` -Create an environment file and replace both credential placeholders: +Erstellen Sie eine Umgebungsdatei und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Use dedicated credentials for the bucket. Do not commit `.env` to source control. +Verwenden Sie dedizierte Zugangsdaten für den Bucket. Nehmen Sie `.env` nicht in die Versionsverwaltung auf. -Elasticsearch splits its S3 settings between `elasticsearch.yml` (non-secret values) and the keystore (credentials). Create the configuration file: +Elasticsearch trennt die S3-Einstellungen zwischen `elasticsearch.yml` (nicht geheime Werte) und dem Keystore (Zugangsdaten). Erstellen Sie die Konfigurationsdatei: ```yaml title="elasticsearch.yml" discovery.type: single-node @@ -47,7 +47,7 @@ s3.client.default.path_style_access: "true" s3.client.default.region: "us-east-1" ``` -Create the Compose file: +Erstellen Sie die Compose-Datei: ```yaml title="compose.yaml" services: @@ -121,26 +121,26 @@ volumes: rustfs-data: ``` -`repository-s3` is a bundled plugin and installs without network access. Only the access key and secret key belong in the keystore — non-secure settings such as the endpoint must live in `elasticsearch.yml`, otherwise the node refuses to start. +`repository-s3` ist ein mitgeliefertes Plugin und wird ohne Netzwerkzugriff installiert. In den Keystore gehören nur der Zugriffsschlüssel und der geheime Zugriffsschlüssel. Nicht geheime Einstellungen wie der Endpunkt müssen in `elasticsearch.yml` stehen, sonst verweigert der Knoten den Start. -## 2. Start the deployment +## 2. Bereitstellung starten -Resolve the Compose file before starting containers: +Prüfen Sie die Compose-Datei, bevor Sie Container starten: ```bash docker compose config ``` -Start the services and wait for Elasticsearch to finish booting (the first start installs the plugin and creates the keystore entries, which takes a minute or two): +Starten Sie die Dienste und warten Sie, bis Elasticsearch hochgefahren ist. Der erste Start installiert das Plugin und legt die Keystore-Einträge an, was ein bis zwei Minuten dauert: ```bash docker compose up -d curl -s http://localhost:9200 ``` -## 3. Register the snapshot repository and index documents +## 3. Snapshot-Repository registrieren und Dokumente indexieren -Register RustFS as the snapshot repository, create an index, and index five documents: +Registrieren Sie RustFS als Snapshot-Repository, legen Sie einen Index an und indexieren Sie fünf Dokumente: ```bash curl -s -X PUT "http://localhost:9200/_snapshot/rustfs_repo" \ @@ -160,32 +160,34 @@ curl -s -X POST "http://localhost:9200/rustfs_index/_refresh" > /dev/null curl -s "http://localhost:9200/rustfs_index/_count" ``` + ```text {"count":5,...} ``` -## 4. Take a snapshot +## 4. Snapshot erstellen -Create a snapshot with `wait_for_completion` so the result is known immediately: +Erstellen Sie einen Snapshot mit `wait_for_completion`, damit das Ergebnis sofort feststeht: ```bash curl -s -X PUT "http://localhost:9200/_snapshot/rustfs_repo/snap1?wait_for_completion=true" ``` + ```text {"snapshot":{"snapshot":"snap1",...,"indices":["rustfs_index"],"shards":{"total":1,"failed":0,"successful":1}}} ``` -## 5. Verify objects in RustFS +## 5. Objekte in RustFS prüfen -List the snapshot objects through the bucket-initializer image: +Listen Sie die Snapshot-Objekte über das Image des Bucket-Initialisierers auf: ```bash docker compose run --rm --entrypoint /bin/sh create-bucket -c \ '/usr/bin/rc alias set rustfs http://rustfs:9000 "$RUSTFS_ACCESS_KEY" "$RUSTFS_SECRET_KEY" >/dev/null && /usr/bin/rc ls rustfs/my-bucket/indices --recursive' ``` -Snapshot metadata and shard data blobs live under `indices/` in the bucket: +Snapshot-Metadaten und Shard-Daten-Blobs liegen im Bucket unter `indices/`: ```text [2026-09-21 02:58:01] 3.56 KiB indices/mvyat2-dSEOG3uiCCiFzRA/0/__LbLsSgUUTpqji_EXvqHYCg @@ -193,13 +195,13 @@ Snapshot metadata and shard data blobs live under `indices/` in the bucket: [2026-09-21 02:58:01] 1.00 KiB indices/mvyat2-dSEOG3uiCCiFzRA/0/index-e9P8q6E9QhitpkiOdgjVDQ ``` -You can also browse the prefix in the RustFS Console: +Sie können das Präfix auch in der RustFS Console (Weboberfläche) durchsuchen: -![Elasticsearch snapshot blobs stored in the RustFS Console](./images/rustfs-es-snapshots.png) +![In der RustFS Console gespeicherte Elasticsearch-Snapshot-Blobs](./images/rustfs-es-snapshots.png) -## 6. Restore the index from RustFS +## 6. Index aus RustFS wiederherstellen -Delete the index, then restore it from the snapshot: +Löschen Sie den Index und stellen Sie ihn anschließend aus dem Snapshot wieder her: ```bash curl -s -X DELETE "http://localhost:9200/rustfs_index" > /dev/null @@ -207,35 +209,36 @@ curl -s -X POST "http://localhost:9200/_snapshot/rustfs_repo/snap1/_restore?wait curl -s "http://localhost:9200/rustfs_index/_count" ``` + ```text {"count":5,...} ``` -The documents come back because the snapshot blobs were read from RustFS. +Die Dokumente sind wieder vorhanden, weil die Snapshot-Blobs aus RustFS gelesen wurden. -## 7. Stop or reset the stack +## 7. Stack anhalten oder zurücksetzen -Stop the containers while keeping the RustFS data volume: +Stoppen Sie die Container und behalten Sie das RustFS-Datenvolumen: ```bash docker compose down ``` -To delete the snapshots and start from an empty RustFS volume, explicitly include `--volumes`: +Um die Snapshots zu löschen und mit einem leeren RustFS-Volume zu beginnen, geben Sie `--volumes` ausdrücklich an: ```bash docker compose down --volumes ``` -## Troubleshooting +## Fehlerbehebung -### The node refuses to start with "non-secure setting ... must be stored inside elasticsearch.yml" +### Der Knoten startet nicht und meldet „non-secure setting ... must be stored inside elasticsearch.yml“ -Only `s3.client.default.access_key` and `s3.client.default.secret_key` belong in the keystore. Endpoint, protocol, path-style access, and region are non-secure settings and must be defined in `elasticsearch.yml`. +In den Keystore gehören nur `s3.client.default.access_key` und `s3.client.default.secret_key`. Endpunkt, Protokoll, pfadbasierte Adressierung und Region sind nicht geheime Einstellungen und müssen in `elasticsearch.yml` definiert sein. -### Restored or new shards stay unassigned +### Wiederhergestellte oder neue Shards bleiben nicht zugewiesen -Elasticsearch stops allocating shards when disk usage passes the low watermark (85 percent by default). Free disk space, or disable the check for a local test: +Elasticsearch weist keine Shards mehr zu, wenn die Festplattennutzung die niedrige Watermark überschreitet (standardmäßig 85 Prozent). Geben Sie Speicherplatz frei oder deaktivieren Sie die Prüfung für einen lokalen Test: ```bash curl -s -X PUT "http://localhost:9200/_cluster/settings" \ @@ -243,20 +246,20 @@ curl -s -X PUT "http://localhost:9200/_cluster/settings" \ -d '{"transient":{"cluster.routing.allocation.disk.threshold_enabled":false}}' ``` -### Restore fails because the index already exists +### Die Wiederherstellung schlägt fehl, weil der Index bereits existiert -A previous failed restore leaves the index behind. Delete it with `DELETE /rustfs_index` and run the restore again. +Eine zuvor fehlgeschlagene Wiederherstellung lässt den Index zurück. Löschen Sie ihn mit `DELETE /rustfs_index` und führen Sie die Wiederherstellung erneut aus. -### AccessDenied or 403 responses +### AccessDenied- oder 403-Antworten -Confirm that the credentials in the keystore match the RustFS credentials and that the `create-bucket` service completed successfully: +Stellen Sie sicher, dass die Zugangsdaten im Keystore mit den RustFS-Zugangsdaten übereinstimmen und dass der Dienst `create-bucket` erfolgreich abgeschlossen wurde: ```bash docker compose logs create-bucket ``` -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional S3 operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Elasticsearch snapshot documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/snapshot-restore.html) for snapshot lifecycle management (SLM). +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Elasticsearch-Snapshot-Dokumentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/snapshot-restore.html) zur Snapshot-Lebenszyklusverwaltung (SLM). diff --git a/content/de/developer/integration/devops/gitea.md b/content/de/developer/integration/devops/gitea.md index 239b6ad25..83ae6a3d0 100644 --- a/content/de/developer/integration/devops/gitea.md +++ b/content/de/developer/integration/devops/gitea.md @@ -1,13 +1,13 @@ --- title: "Gitea" -description: "Run Gitea with RustFS as the S3 storage backend for LFS objects and attachments, deployed with Docker Compose." +description: "Betreiben Sie Gitea mit RustFS als S3-Speicher-Backend für LFS-Objekte und Anhänge, bereitgestellt mit Docker Compose." --- -This guide connects [Gitea](https://github.com/go-gitea/gitea) — the self-hosted Git service — to **RustFS** through Gitea's `minio` storage type. You will start Gitea with Docker Compose, create a repository, push a Git LFS object, attach a file to an issue, and verify that both the LFS object and the attachment are stored in RustFS. The workflow was verified with `gitea/gitea:1.24.4` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Gitea](https://github.com/go-gitea/gitea) — den selbst gehosteten Git-Dienst — über den Speichertyp `minio` von Gitea mit **RustFS**. Sie starten Gitea mit Docker Compose, legen ein Repository an, pushen ein Git-LFS-Objekt, hängen eine Datei an ein Issue an und prüfen, dass sowohl das LFS-Objekt als auch der Anhang in RustFS gespeichert werden. Der Ablauf wurde mit `gitea/gitea:1.24.4` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker with the Compose plugin and the `git` and `git-lfs` clients on your workstation. This deployment is intended for local integration testing, not production. +Sie benötigen Docker mit dem Compose-Plugin sowie die Clients `git` und `git-lfs` auf Ihrer Arbeitsstation. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,27 +15,27 @@ flowchart LR Gitea -->|"LFS + attachments"| RustFS["RustFS :9000"] ``` -Gitea stores the Git repository itself on its local disk, while the `minio` storage type routes large files — LFS objects, issue attachments, avatars, repository archives, packages, and Actions artifacts — to the `gitea-data` bucket in RustFS. Gitea creates the bucket on startup if it does not exist. +Gitea speichert das Git-Repository selbst auf der lokalen Festplatte. Der Speichertyp `minio` leitet große Dateien — LFS-Objekte, Issue-Anhänge, Avatare, Repository-Archive, Pakete und Actions-Artefakte — in den Bucket `gitea-data` in RustFS. Gitea legt den Bucket beim Start an, wenn er noch nicht existiert. -## 1. Create the project files +## 1. Projektdateien anlegen -Create a working directory: +Erstellen Sie ein Arbeitsverzeichnis: ```bash mkdir rustfs-gitea cd rustfs-gitea ``` -Create an environment file and replace both credential placeholders: +Erstellen Sie eine Umgebungsdatei und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Use dedicated credentials for the `gitea-data` bucket. Do not commit `.env` to source control. +Verwenden Sie dedizierte Zugangsdaten für den Bucket `gitea-data`. Nehmen Sie `.env` nicht in die Versionsverwaltung auf. -Create the Gitea configuration and replace both credential placeholders with the same values you set in `.env` — the global `minio` storage type applies to LFS, attachments, avatars, repository archives, packages, and Actions artifacts: +Erstellen Sie die Gitea-Konfiguration und ersetzen Sie beide Platzhalter für die Zugangsdaten durch dieselben Werte wie in `.env`. Der globale Speichertyp `minio` gilt für LFS, Anhänge, Avatare, Repository-Archive, Pakete und Actions-Artefakte: ```ini title="app.ini" APP_NAME = RustFS Gitea @@ -70,9 +70,9 @@ INSTALL_LOCK = true SECRET_KEY = change-me-to-a-random-string ``` -`LFS_START_SERVER` enables the Git LFS HTTP API. `MINIO_ENDPOINT` uses the Compose-internal hostname `rustfs`; the endpoint is reached with path-style requests by default. +`LFS_START_SERVER` aktiviert die Git-LFS-HTTP-API. `MINIO_ENDPOINT` verwendet den Compose-internen Hostnamen `rustfs`. Der Endpunkt wird standardmäßig mit pfadbasierter Adressierung (Path-Style) erreicht. -Create the Compose file: +Erstellen Sie die Compose-Datei: ```yaml title="compose.yaml" services: @@ -123,36 +123,36 @@ volumes: gitea-data: ``` -The volume-backed `/data` directory keeps the SQLite database and the Git repositories across container restarts, while LFS objects and attachments live in RustFS. +Das von einem Volume gestützte Verzeichnis `/data` behält die SQLite-Datenbank und die Git-Repositories über Container-Neustarts hinweg. LFS-Objekte und Anhänge liegen in RustFS. -## 2. Validate and start the deployment +## 2. Bereitstellung prüfen und starten -Resolve the Compose file before starting containers: +Prüfen Sie die Compose-Datei, bevor Sie Container starten: ```bash docker compose config ``` -Start the services: +Starten Sie die Dienste: ```bash docker compose up -d docker compose ps ``` -Watch the Gitea log until every storage backend reports the Minio type: +Beobachten Sie das Gitea-Protokoll, bis jedes Speicher-Backend den Typ Minio meldet: ```bash docker compose logs gitea | grep "Initialising" ``` -The output should list `Attachment`, `Avatar`, `LFS`, and the remaining storage sections, each followed by a `Creating Minio storage at rustfs:9000:gitea-data` line. +Die Ausgabe sollte `Attachment`, `Avatar`, `LFS` und die übrigen Speicherabschnitte auflisten, jeweils gefolgt von einer Zeile `Creating Minio storage at rustfs:9000:gitea-data`. -Open `http://localhost:3000` and create the administrator account, then open the RustFS Console at `http://localhost:9001` — the `gitea-data` bucket appears after the first storage operation. +Öffnen Sie `http://localhost:3000` und legen Sie das Administratorkonto an. Öffnen Sie anschließend die RustFS Console (Weboberfläche) unter `http://localhost:9001`. Der Bucket `gitea-data` erscheint nach der ersten Speicheroperation. -## 3. Push a Git LFS object +## 3. Git-LFS-Objekt pushen -Create a repository named `rustfs-demo` in the Gitea web UI, then push an LFS-tracked file from your workstation: +Legen Sie in der Gitea-Weboberfläche ein Repository namens `rustfs-demo` an und pushen Sie anschließend eine von LFS verfolgte Datei von Ihrer Arbeitsstation: ```bash mkdir lfs-demo && cd lfs-demo @@ -169,68 +169,68 @@ git remote add origin http://localhost:3000//rustfs-demo.git git push origin main ``` -`git push` uploads the LFS object through the Gitea LFS API, which writes it to RustFS. Clone the repository into a second directory and run `git lfs pull` — the downloaded `dataset.bin` must be byte-identical to the original: +`git push` lädt das LFS-Objekt über die Gitea-LFS-API hoch, die es nach RustFS schreibt. Klonen Sie das Repository in ein zweites Verzeichnis und führen Sie `git lfs pull` aus. Die heruntergeladene Datei `dataset.bin` muss byteweise mit dem Original übereinstimmen: ```bash sha256sum dataset.bin cd ../lfs-demo-clone && git lfs pull && sha256sum dataset.bin ``` -Both checksums match because both clients read the object from RustFS. +Beide Prüfsummen stimmen überein, weil beide Clients das Objekt aus RustFS lesen. -## 4. Attach a file to an issue +## 4. Datei an ein Issue anhängen -Open the `rustfs-demo` repository, create an issue, and attach a small text file through the issue form. Gitea stores the upload as `attachments//` in the `gitea-data` bucket and serves downloads through `/attachments/`. +Öffnen Sie das Repository `rustfs-demo`, legen Sie ein Issue an und hängen Sie über das Issue-Formular eine kleine Textdatei an. Gitea speichert den Upload als `attachments//` im Bucket `gitea-data` und liefert Downloads über `/attachments/` aus. -## 5. Verify objects in RustFS +## 5. Objekte in RustFS prüfen -List the bucket with the [`rc` client](https://github.com/rustfs/cli): +Listen Sie den Bucket mit dem [`rc`-Client](https://github.com/rustfs/cli) auf: ```bash docker compose exec rustfs /usr/bin/rc ls local/gitea-data/ -r ``` -The output should include the LFS object under `lfs/` and the attachment under `attachments/`: +Die Ausgabe sollte das LFS-Objekt unter `lfs/` und den Anhang unter `attachments/` enthalten: ```text attachments/9/2/92fdd48d-531c-4cba-8b3f-4e2004a10fc7 lfs/37/76/6ddfc07e803de58a69328db9a58a07cf7080ddde55c155a7531bc650a000 ``` -The LFS object key is the SHA-256 content hash used by the Git LFS protocol. +Der LFS-Objektschlüssel ist der SHA-256-Inhaltshash des Git-LFS-Protokolls. -![Gitea LFS and attachment objects in the RustFS Console](./images/rustfs-gitea-objects.png) +![Gitea-LFS- und Anhang-Objekte in der RustFS Console](./images/rustfs-gitea-objects.png) -## 6. Stop or reset the deployment +## 6. Bereitstellung anhalten oder zurücksetzen -Stop the containers while keeping all data: +Stoppen Sie die Container und behalten Sie alle Daten: ```bash docker compose down ``` -The RustFS volume keeps the `gitea-data` bucket, so LFS objects and attachments survive a restart. To delete everything, including the objects in RustFS, add `--volumes`. +Das RustFS-Volume behält den Bucket `gitea-data`, daher überstehen LFS-Objekte und Anhänge einen Neustart. Um alles zu löschen, einschließlich der Objekte in RustFS, fügen Sie `--volumes` hinzu. -## Troubleshooting +## Fehlerbehebung -### The Gitea install page appears instead of the login page +### Statt der Anmeldeseite erscheint die Gitea-Installationsseite -The configuration file must exist at `/data/gitea/conf/app.ini` inside the container. If the mount path is wrong, Gitea starts with defaults and shows the installation wizard. Mount the file as shown in the Compose example and restart. +Die Konfigurationsdatei muss im Container unter `/data/gitea/conf/app.ini` liegen. Ist der Mount-Pfad falsch, startet Gitea mit den Standardwerten und zeigt den Installationsassistenten. Hängen Sie die Datei wie im Compose-Beispiel ein und starten Sie neu. -### Push fails with an LFS or 403 error +### Der Push schlägt mit einem LFS- oder 403-Fehler fehl -Confirm the credentials in `app.ini` match the RustFS credentials and that the `rustfs` hostname resolves inside the Compose network: +Stellen Sie sicher, dass die Zugangsdaten in `app.ini` mit den RustFS-Zugangsdaten übereinstimmen und dass der Hostname `rustfs` im Compose-Netzwerk aufgelöst wird: ```bash docker compose logs gitea | grep -i minio ``` -### Objects land in local storage instead of RustFS +### Objekte landen im lokalen Speicher statt in RustFS -The `GITEA__storage__STORAGE_TYPE: minio` environment variable and the `[storage]` section of `app.ini` must agree. After changing either, restart Gitea and check the `Initialising` log lines again. +Die Umgebungsvariable `GITEA__storage__STORAGE_TYPE: minio` und der Abschnitt `[storage]` in `app.ini` müssen übereinstimmen. Starten Sie Gitea nach einer Änderung neu und prüfen Sie die Logzeilen `Initialising` erneut. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Gitea storage targets. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Gitea storage documentation](https://docs.gitea.com/administration/storage-configurations) to move packages, Actions artifacts, or individual storage sections to separate buckets. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Gitea-Speicherziele verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Gitea-Speicher-Dokumentation](https://docs.gitea.com/administration/storage-configurations), um Pakete, Actions-Artefakte oder einzelne Speicherabschnitte in eigene Buckets zu verlagern. diff --git a/content/de/developer/integration/devops/jenkins.md b/content/de/developer/integration/devops/jenkins.md index 1d78f31b0..413ea9945 100644 --- a/content/de/developer/integration/devops/jenkins.md +++ b/content/de/developer/integration/devops/jenkins.md @@ -1,13 +1,13 @@ --- title: "Jenkins" -description: "Store Jenkins build artifacts in RustFS with the Artifact Manager on S3 plugin." +description: "Speichern Sie Jenkins-Build-Artefakte mit dem Plugin Artifact Manager on S3 in RustFS." --- -This guide connects [Jenkins](https://github.com/jenkinsci/jenkins) — the automation server — to **RustFS** through the Artifact Manager on S3 plugin. You will start Jenkins with the plugin, point its artifact manager at a RustFS bucket, run a job that archives an artifact, and verify that the artifact is stored in RustFS. The workflow was verified with `jenkins/jenkins:lts-jdk17` (Jenkins 2.5xx LTS) and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Jenkins](https://github.com/jenkinsci/jenkins) — den Automatisierungsserver — über das Plugin Artifact Manager on S3 mit **RustFS**. Sie starten Jenkins mit dem Plugin, richten den Artifact Manager auf einen RustFS-Bucket aus, führen einen Job aus, der ein Artefakt archiviert, und prüfen, dass das Artefakt in RustFS gespeichert wird. Der Ablauf wurde mit `jenkins/jenkins:lts-jdk17` (Jenkins 2.5xx LTS) und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,18 +15,18 @@ flowchart LR J -->|"archiveArtifacts"| RustFS["RustFS :9000"] ``` -With the plugin active, every job that publishes artifacts through the standard `archiveArtifacts` step (or `stash`/`unstash`) uploads them to the `jenkins-artifacts` bucket under the configured prefix instead of storing them on the controller disk. +Wenn das Plugin aktiv ist, lädt jeder Job, der Artefakte über den Standardschritt `archiveArtifacts` (oder `stash`/`unstash`) veröffentlicht, sie unter dem konfigurierten Präfix in den Bucket `jenkins-artifacts` hoch, statt sie auf der Festplatte des Controllers zu speichern. -## 1. Create the project files +## 1. Projektdateien anlegen -Create the bucket first — the plugin validates the bucket but does not create it: +Legen Sie zuerst den Bucket an. Das Plugin prüft den Bucket, legt ihn aber nicht an: ```bash rc alias set rustfs http://:9000 rc mb rustfs/jenkins-artifacts ``` -Create a Dockerfile that installs the plugin into the Jenkins LTS image: +Erstellen Sie ein Dockerfile, das das Plugin in das Jenkins-LTS-Image installiert: ```dockerfile title="Dockerfile" FROM jenkins/jenkins:lts-jdk17 @@ -35,9 +35,9 @@ RUN jenkins-plugin-cli --plugins artifact-manager-s3 aws-credentials USER jenkins ``` -The `artifact-manager-s3` plugin brings in the AWS credentials support it needs; listing `aws-credentials` explicitly keeps the credential type available. +Das Plugin `artifact-manager-s3` bringt die AWS-Zugangsdatenunterstützung mit, die es benötigt. Wenn Sie `aws-credentials` ausdrücklich angeben, bleibt der Typ **AWS Credential** verfügbar. -Build and start Jenkins on the same Docker network as RustFS: +Bauen Sie das Image und starten Sie Jenkins im selben Docker-Netzwerk wie RustFS: ```bash docker build -t jenkins-rustfs . @@ -45,31 +45,31 @@ docker run -d --name jenkins --network oo-rustfs_default \ -p 8080:8080 -v jenkins-home:/var/jenkins_home jenkins-rustfs ``` -Complete the setup wizard, then create an AWS credential: **Manage Jenkins → Credentials → global → Add Credentials**, kind **AWS Credential**, ID `rustfs-creds`, with your RustFS access key and secret key. +Schließen Sie den Einrichtungsassistenten ab und legen Sie anschließend AWS-Zugangsdaten an: **Manage Jenkins → Credentials → global → Add Credentials** (Jenkins verwalten, Zugangsdaten, global, Zugangsdaten hinzufügen). Wählen Sie die Art **AWS Credential**, die ID `rustfs-creds` und tragen Sie Ihren RustFS-Zugriffsschlüssel sowie den geheimen Zugriffsschlüssel ein. -## 2. Configure the artifact manager +## 2. Artifact Manager konfigurieren -Open **Manage Jenkins → AWS Configuration** (from the `aws-global-configuration` plugin) and set: +Öffnen Sie **Manage Jenkins → AWS Configuration** (aus dem Plugin `aws-global-configuration`) und setzen Sie: - **Region name**: `us-east-1` - **Credentials**: `rustfs-creds` -Open **Manage Jenkins → System** and locate the **Artifact Management for Builds** section. Select **Cloud Provider Amazon S3**, and fill in the S3 configuration: +Öffnen Sie **Manage Jenkins → System** und suchen Sie den Abschnitt **Artifact Management for Builds** (Artefaktverwaltung für Builds). Wählen Sie **Cloud Provider Amazon S3** und füllen Sie die S3-Konfiguration aus: - **S3 Bucket Name**: `jenkins-artifacts` - **S3 Bucket Region**: `us-east-1` - **Base Prefix**: `artifacts/` -- **Custom Endpoint**: `:9000` (for example `rustfs:9000` inside the Compose network) +- **Custom Endpoint**: `:9000` (zum Beispiel `rustfs:9000` im Compose-Netzwerk) - **Custom Signing Region**: `us-east-1` -- **Use Path Style URL**: enabled -- **Use Insecure HTTP**: enabled -- **Disable Session Token**: enabled +- **Use Path Style URL**: aktiviert +- **Use Insecure HTTP**: aktiviert +- **Disable Session Token**: aktiviert -Path-style addressing and plain HTTP are required for a non-AWS endpoint without TLS. Disabling the session token stops the plugin from calling AWS STS, which a plain access key pair cannot answer. Click **Validate S3 Bucket configuration** to confirm the settings, then save. +Für einen Nicht-AWS-Endpunkt ohne TLS sind pfadbasierte Adressierung (Path-Style) und unverschlüsseltes HTTP erforderlich. Wenn Sie das Session-Token deaktivieren, ruft das Plugin kein AWS STS auf. Ein statisches Zugriffsschlüsselpaar kann einen STS-Aufruf nicht beantworten. Klicken Sie auf **Validate S3 Bucket configuration** (S3-Bucket-Konfiguration prüfen), um die Einstellungen zu bestätigen, und speichern Sie anschließend. -## 3. Run a job that archives an artifact +## 3. Job ausführen, der ein Artefakt archiviert -Create a freestyle job (or pipeline) that produces a file and archives it: +Legen Sie einen Freestyle-Job (oder eine Pipeline) an, der eine Datei erzeugt und archiviert: ```groovy pipeline { @@ -89,56 +89,56 @@ pipeline { } ``` -Run the build and wait for it to finish. The artifact upload goes to RustFS transparently — the job configuration does not mention S3 at all. +Führen Sie den Build aus und warten Sie, bis er abgeschlossen ist. Die Artefakte werden transparent nach RustFS hochgeladen. Die Job-Konfiguration erwähnt S3 dabei nicht. -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/jenkins-artifacts/ -r ``` -The artifact is stored under the prefix, organized by job and build number: +Das Artefakt liegt unter dem Präfix, geordnet nach Job und Build-Nummer: ```text artifacts/s3-artifacts-demo/3/artifacts/report.txt ``` -![Jenkins artifacts stored in the RustFS Console](./images/rustfs-jenkins-artifacts.png) +![In der RustFS Console gespeicherte Jenkins-Artefakte](./images/rustfs-jenkins-artifacts.png) -Downloading the artifact from the build page reads it back from RustFS. +Wenn Sie das Artefakt von der Build-Seite herunterladen, wird es aus RustFS gelesen. -## 5. Stop or reset the deployment +## 5. Bereitstellung anhalten oder zurücksetzen -Stop Jenkins while keeping the data: +Stoppen Sie Jenkins und behalten Sie die Daten: ```bash docker rm -f jenkins ``` -The artifacts stay in the `jenkins-artifacts` bucket. To delete them, remove the bucket: +Die Artefakte bleiben im Bucket `jenkins-artifacts`. Um sie zu löschen, entfernen Sie den Bucket: ```bash rc rb rustfs/jenkins-artifacts --force ``` -## Troubleshooting +## Fehlerbehebung ### `StsException: The security token included in the request is invalid` -The plugin is calling AWS STS to obtain session credentials. Enable **Disable Session Token** in the S3 configuration — a static access key pair cannot answer an STS call. +Das Plugin ruft AWS STS auf, um Sitzungs-Zugangsdaten zu beziehen. Aktivieren Sie **Disable Session Token** in der S3-Konfiguration. Ein statisches Zugriffsschlüsselpaar kann einen STS-Aufruf nicht beantworten. ### `UnknownHostException: jenkins-artifacts.rustfs` -The plugin is using virtual-hosted addressing. Enable **Use Path Style URL** — RustFS resolves buckets from the URL path, not the hostname. +Das Plugin verwendet Adressierung im Virtual-Hosted-Stil. Aktivieren Sie **Use Path Style URL**. RustFS ermittelt Buckets aus dem URL-Pfad, nicht aus dem Hostnamen. -### `No valid session credentials` or empty credential errors +### `No valid session credentials` oder Fehler mit leeren Zugangsdaten -Confirm the AWS Configuration page has the credential selected and saved **before** the S3 bucket settings are used, and that the credential ID matches the one you created. +Stellen Sie sicher, dass auf der Seite AWS Configuration die Zugangsdaten ausgewählt und gespeichert sind, **bevor** die S3-Bucket-Einstellungen verwendet werden, und dass die ID der Zugangsdaten der von Ihnen angelegten ID entspricht. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Jenkins integrations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Artifact Manager on S3 plugin documentation](https://plugins.jenkins.io/artifact-manager-s3/) for stash support and cleanup options. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Jenkins-Integrationen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Dokumentation zum Plugin Artifact Manager on S3](https://plugins.jenkins.io/artifact-manager-s3/) für die Stash-Unterstützung und Bereinigungsoptionen. diff --git a/content/de/developer/integration/devops/opensearch.md b/content/de/developer/integration/devops/opensearch.md index 9d44e530b..c97eb3a53 100644 --- a/content/de/developer/integration/devops/opensearch.md +++ b/content/de/developer/integration/devops/opensearch.md @@ -1,13 +1,13 @@ --- title: "OpenSearch" -description: "Snapshot OpenSearch indices to RustFS with the repository-s3 plugin." +description: "Sichern Sie OpenSearch-Indizes mit dem Plugin repository-s3 als Snapshots in RustFS." --- -This guide connects [OpenSearch](https://github.com/opensearch-project/OpenSearch) — the open-source search and analytics suite derived from Elasticsearch — to **RustFS** through the `repository-s3` plugin. You will register an S3 snapshot repository backed by a RustFS bucket, take a snapshot of an index, and restore it. The workflow was verified with `opensearchproject/opensearch:3.8.0` and the bundled `repository-s3` plugin against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [OpenSearch](https://github.com/opensearch-project/OpenSearch) — die quelloffene Such- und Analyse-Suite, die von Elasticsearch abgeleitet ist — über das Plugin `repository-s3` mit **RustFS**. Sie registrieren ein S3-Snapshot-Repository auf einem RustFS-Bucket, erstellen einen Snapshot eines Index und stellen ihn wieder her. Der Ablauf wurde mit `opensearchproject/opensearch:3.8.0` und dem mitgelieferten Plugin `repository-s3` gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker, or an OpenSearch node where you can install plugins and edit configuration. This deployment is intended for local integration testing, not production. +Sie benötigen Docker oder einen OpenSearch-Knoten, auf dem Sie Plugins installieren und die Konfiguration bearbeiten können. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,11 +16,11 @@ flowchart LR RustFS -->|"restore"| OS ``` -The `repository-s3` plugin writes snapshots as shard archives plus metadata blobs in the bucket. Registration is cluster-wide, so every node needs the plugin and the same client configuration. +Das Plugin `repository-s3` schreibt Snapshots als Shard-Archive plus Metadaten-Blobs in den Bucket. Die Registrierung gilt clusterweit, daher benötigt jeder Knoten das Plugin und dieselbe Client-Konfiguration. -## 1. Run OpenSearch +## 1. OpenSearch ausführen -Start a single node with security disabled and a small heap: +Starten Sie einen einzelnen Knoten mit deaktiviertem Security-Plugin und einem kleinen Heap: ```bash docker run -d --name opensearch --network oo-rustfs_default -p 9200:9200 \ @@ -30,20 +30,20 @@ docker run -d --name opensearch --network oo-rustfs_default -p 9200:9200 \ opensearchproject/opensearch:3.8.0 ``` -The node is ready when `curl http://localhost:9200` returns the cluster header (allow one to two minutes). +Der Knoten ist bereit, wenn `curl http://localhost:9200` den Cluster-Header zurückgibt. Rechnen Sie mit ein bis zwei Minuten. -## 2. Install the repository-s3 plugin +## 2. Plugin repository-s3 installieren -The S3 repository plugin is not preloaded. Install it and restart the node: +Das S3-Repository-Plugin ist nicht vorgeladen. Installieren Sie es und starten Sie den Knoten neu: ```bash docker exec opensearch bin/opensearch-plugin install --batch repository-s3 docker restart opensearch ``` -## 3. Configure the S3 client +## 3. S3-Client konfigurieren -Credentials are secure settings: they belong in the OpenSearch keystore, not in the repository request or `opensearch.yml`. Create the keystore entries, replacing all connection placeholders: +Zugangsdaten sind sichere Einstellungen. Sie gehören in den OpenSearch-Keystore, nicht in die Repository-Anfrage oder in `opensearch.yml`. Legen Sie die Keystore-Einträge an und ersetzen Sie alle Verbindungsplatzhalter: ```bash docker exec opensearch sh -c \ @@ -52,7 +52,7 @@ docker exec opensearch sh -c \ printf '' | bin/opensearch-keystore add -f -x s3.client.default.secret_key" ``` -Add the non-secure client settings to `config/opensearch.yml`: +Fügen Sie die nicht geheimen Client-Einstellungen zu `config/opensearch.yml` hinzu: ```yaml title="opensearch.yml" network.host: 0.0.0.0 @@ -62,21 +62,21 @@ s3.client.default.protocol: http s3.client.default.path_style_access: "true" ``` -Restart the node once more so it reads both the keystore and the new settings: +Starten Sie den Knoten ein weiteres Mal neu, damit er sowohl den Keystore als auch die neuen Einstellungen liest: ```bash docker restart opensearch ``` -Create the bucket while the node boots: +Legen Sie den Bucket an, während der Knoten startet: ```bash rc mb rustfs/opensearch-snapshots ``` -## 4. Register the repository and snapshot +## 4. Repository registrieren und Snapshot erstellen -Create a test index with a document, then register the repository: +Legen Sie einen Testindex mit einem Dokument an und registrieren Sie anschließend das Repository: ```bash curl -sX PUT http://localhost:9200/rustfs-demo -H "Content-Type: application/json" \ @@ -89,27 +89,29 @@ curl -sX PUT "http://localhost:9200/_snapshot/rustfs-repo" -H "Content-Type: app -d '{"type":"s3","settings":{"bucket":"opensearch-snapshots","region":"us-east-1","server_side_encryption_type":"bucket_default"}}' ``` -The `server_side_encryption_type: bucket_default` setting matters: without it the plugin requests SSE-S3, which a self-hosted RustFS without a server-side encryption master key rejects. +Die Einstellung `server_side_encryption_type: bucket_default` ist wichtig. Ohne sie fordert das Plugin SSE-S3 an. Eine selbst betriebene RustFS-Instanz ohne Master-Schlüssel für die serverseitige Verschlüsselung lehnt das ab. -Take a snapshot and wait for completion: +Erstellen Sie einen Snapshot und warten Sie auf den Abschluss: ```bash curl -sX PUT "http://localhost:9200/_snapshot/rustfs-repo/snapshot-1?wait_for_completion=true" \ -H "Content-Type: application/json" -d '{"indices":"rustfs-demo"}' ``` + ```text {"snapshot":{"snapshot":"snapshot-1","state":"SUCCESS","indices":["rustfs-demo"],...}} ``` -## 5. Verify objects and restore +## 5. Objekte prüfen und wiederherstellen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/opensearch-snapshots/ -r ``` + ```text index-0 index.latest @@ -119,7 +121,7 @@ meta-kRgFBiuyQIyPo3_-CMp7Hw.dat snap-kRgFBiuyQIyPo3_-CMp7Hw.dat ``` -Delete the index and restore it from the snapshot: +Löschen Sie den Index und stellen Sie ihn aus dem Snapshot wieder her: ```bash curl -sX DELETE http://localhost:9200/rustfs-demo @@ -127,46 +129,47 @@ curl -sX POST "http://localhost:9200/_snapshot/rustfs-repo/snapshot-1/_restore?w curl -s http://localhost:9200/rustfs-demo/_doc/1 ``` + ```text {"_index":"rustfs-demo","_id":"1","found":true,"_source":{"product":"rustfs","via":"opensearch-snapshot"}} ``` -![OpenSearch snapshot stored in the RustFS Console](./images/rustfs-opensearch-snapshot.png) +![In der RustFS Console gespeicherter OpenSearch-Snapshot](./images/rustfs-opensearch-snapshot.png) -## 6. Stop or reset +## 6. Anhalten oder zurücksetzen -To tear down the demo while keeping the bucket objects: +So bauen Sie die Demo ab und behalten die Objekte im Bucket: ```bash docker rm -f opensearch ``` -To delete the stored snapshots: +So löschen Sie die gespeicherten Snapshots: ```bash rc rm rustfs/opensearch-snapshots/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `Setting [access_key] is insecure, but property [allow_insecure_settings] is not set` -Inline credentials in the repository request are rejected. Store them in the keystore as shown in step 3 — `access_key` and `secret_key` are secure settings in OpenSearch. +Zugangsdaten direkt in der Repository-Anfrage werden abgelehnt. Speichern Sie sie wie in Schritt 3 im Keystore. `access_key` und `secret_key` sind in OpenSearch sichere Einstellungen. ### `SSE-S3 requires RUSTFS_SSE_S3_MASTER_KEY ... (Status Code: 400)` -The plugin encrypts uploads with SSE-S3 by default. Register the repository with `"server_side_encryption_type": "bucket_default"` so no encryption header is sent, as in step 4. +Das Plugin verschlüsselt Uploads standardmäßig mit SSE-S3. Registrieren Sie das Repository mit `"server_side_encryption_type": "bucket_default"`, damit kein Verschlüsselungs-Header gesendet wird, wie in Schritt 4. -### `unknown setting [s3.client.default.access_key]` at startup +### `unknown setting [s3.client.default.access_key]` beim Start -The settings reference the repository-s3 plugin. If the node fails to start with them present, the plugin is not installed in that container — repeat step 2 (a fresh container loses plugins installed with `docker exec`). +Die Einstellungen verweisen auf das Plugin repository-s3. Wenn der Knoten mit diesen Einstellungen nicht startet, ist das Plugin in diesem Container nicht installiert. Wiederholen Sie Schritt 2. Ein neuer Container verliert Plugins, die mit `docker exec` installiert wurden. -### Repository verification fails with `path is not accessible` +### Die Repository-Prüfung schlägt mit `path is not accessible` fehl -The node cannot reach the bucket: check that `s3.client.default.endpoint` is reachable from the container, `path_style_access` is `"true"`, and the keystore credentials were loaded (they are read at startup — restart after adding them). +Der Knoten erreicht den Bucket nicht. Prüfen Sie, dass `s3.client.default.endpoint` vom Container aus erreichbar ist, `path_style_access` den Wert `"true"` hat und die Keystore-Zugangsdaten geladen wurden. Sie werden beim Start gelesen. Starten Sie neu, nachdem Sie sie hinzugefügt haben. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional OpenSearch repositories. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [OpenSearch snapshots documentation](https://docs.opensearch.org/docs/latest/tuning-your-cluster/availability-and-recovery/snapshots/index/) to automate snapshots with Snapshot Management (SM) policies. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere OpenSearch-Repositories verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [OpenSearch-Snapshot-Dokumentation](https://docs.opensearch.org/docs/latest/tuning-your-cluster/availability-and-recovery/snapshots/index/), um Snapshots mit Richtlinien der Snapshot-Verwaltung (SM) zu automatisieren. diff --git a/content/de/developer/integration/devops/terraform.md b/content/de/developer/integration/devops/terraform.md index 8744833a2..f7a026a59 100644 --- a/content/de/developer/integration/devops/terraform.md +++ b/content/de/developer/integration/devops/terraform.md @@ -1,31 +1,31 @@ --- title: "Terraform" -description: "Store Terraform state in RustFS object storage with the S3 backend, including state locking." +description: "Speichern Sie den Terraform-State einschließlich der State-Sperre mit dem S3-Backend im RustFS-Objektspeicher." --- -This guide connects [Terraform](https://github.com/hashicorp/terraform) — the infrastructure as code tool from HashiCorp — to **RustFS** through the S3 backend: the state file, and the lock file that prevents concurrent runs, are stored as objects in RustFS. You will initialize the backend, apply a small configuration, and verify the state object in RustFS. The workflow was verified with `terraform 1.12.2` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Terraform](https://github.com/hashicorp/terraform) — das Infrastructure-as-Code-Werkzeug von HashiCorp — über das S3-Backend mit **RustFS**. Die State-Datei und die Sperrdatei, die parallele Läufe verhindert, werden als Objekte in RustFS gespeichert. Sie initialisieren das Backend, wenden eine kleine Konfiguration an und prüfen das State-Objekt in RustFS. Der Ablauf wurde mit `terraform 1.12.2` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need a RustFS deployment reachable from your workstation (see the guides under [Installation](/installation)) and Terraform 1.10 or later, which supports S3-native locking via `use_lockfile`. +Sie benötigen eine RustFS-Bereitstellung, die von Ihrer Arbeitsstation aus erreichbar ist (siehe die Anleitungen unter [Installation](/de/installation)), und Terraform 1.10 oder neuer. Diese Version unterstützt die native S3-Sperre über `use_lockfile`. -## Architecture +## Architektur ```mermaid flowchart LR Client["terraform init / apply"] -->|"state + lock objects"| RustFS["RustFS :9000"] ``` -The S3 backend stores the state file under the `key` prefix in the bucket. With `use_lockfile = true`, Terraform writes a `.tflock` object while a run holds the lock, replacing the former DynamoDB-based locking for this setup. +Das S3-Backend speichert die State-Datei unter dem Präfix `key` im Bucket. Mit `use_lockfile = true` schreibt Terraform ein Objekt `.tflock`, solange ein Lauf die Sperre hält. Das ersetzt für dieses Setup die frühere Sperre auf Basis von DynamoDB. -## 1. Create the project files +## 1. Projektdateien anlegen -Create a working directory: +Erstellen Sie ein Arbeitsverzeichnis: ```bash mkdir rustfs-terraform cd rustfs-terraform ``` -Create the configuration. Replace the credential placeholders and point the endpoint at your RustFS server — `localhost:9000` when Terraform runs on the same host: +Erstellen Sie die Konfiguration. Ersetzen Sie die Platzhalter für die Zugangsdaten und richten Sie den Endpunkt auf Ihren RustFS-Server aus. Verwenden Sie `localhost:9000`, wenn Terraform auf demselben Host läuft: ```hcl title="main.tf" terraform { @@ -54,36 +54,38 @@ resource "local_file" "demo" { } ``` -`force_path_style` and `insecure` select path-style addressing over plain HTTP, which is what RustFS expects for the local endpoint. `use_lockfile` enables S3-native state locking so concurrent runs cannot corrupt the state. +`force_path_style` und `insecure` wählen pfadbasierte Adressierung (Path-Style) über unverschlüsseltes HTTP. Genau das erwartet RustFS für den lokalen Endpunkt. `use_lockfile` aktiviert die native S3-State-Sperre, damit parallele Läufe den State nicht beschädigen können. -## 2. Initialize the backend +## 2. Backend initialisieren -Download the provider and configure the S3 backend: +Laden Sie den Provider herunter und konfigurieren Sie das S3-Backend: ```bash terraform init -input=false ``` + ```text Successfully configured the backend "s3"! Terraform will automatically use this backend unless the backend configuration changes. ``` -## 3. Apply the configuration +## 3. Konfiguration anwenden -Create the resource and write the state to RustFS: +Legen Sie die Ressource an und schreiben Sie den State nach RustFS: ```bash terraform apply -auto-approve -input=false ``` + ```text Apply complete! Resources: 1 added, 0 changed, 0 destroyed. ``` -## 4. Verify the state in RustFS +## 4. State in RustFS prüfen -List the state objects through the `rc` CLI: +Listen Sie die State-Objekte über die `rc`-CLI auf: ```bash docker run --rm --network -v "$PWD:/m" \ @@ -91,54 +93,56 @@ docker run --rm --network -v "$PWD:/m" \ -c 'rc alias set rustfs http://rustfs:9000 >/dev/null && rc ls rustfs/my-bucket/rustfs-demo --recursive' ``` + ```text [2026-09-21 03:05:03] 1.62 KiB rustfs-demo/terraform.tfstate ``` -You can also browse the prefix in the RustFS Console: +Sie können das Präfix auch in der RustFS Console (Weboberfläche) durchsuchen: -![The Terraform state file stored in the RustFS Console](./images/rustfs-terraform-state.png) +![Die in der RustFS Console gespeicherte Terraform-State-Datei](./images/rustfs-terraform-state.png) -## 5. Confirm the state is reloaded from RustFS +## 5. Prüfen, dass der State aus RustFS neu geladen wird -Run a plan — Terraform reads the state from RustFS and compares it against the configuration: +Führen Sie einen Plan aus. Terraform liest den State aus RustFS und vergleicht ihn mit der Konfiguration: ```bash terraform plan -input=false ``` + ```text No changes. Your infrastructure matches the configuration. ``` -The plan is clean because the state was read back from RustFS, not from any local file. +Der Plan meldet keine Änderungen, weil der State aus RustFS zurückgelesen wurde und nicht aus einer lokalen Datei. -## 6. Destroy and reset +## 6. Zerstören und zurücksetzen -Tear the resource down; the state update is written to RustFS the same way: +Bauen Sie die Ressource ab. Die State-Aktualisierung wird auf dieselbe Weise nach RustFS geschrieben: ```bash terraform destroy -auto-approve -input=false ``` -Delete the state objects in the RustFS Console (or with `rc rm`) to start from scratch. +Löschen Sie die State-Objekte in der RustFS Console (oder mit `rc rm`), um von vorn zu beginnen. -## Troubleshooting +## Fehlerbehebung -### "dial tcp: lookup rustfs ... server misbehaving" or connection failures +### „dial tcp: lookup rustfs ... server misbehaving“ oder Verbindungsfehler -The `endpoint` must be reachable from the machine where Terraform runs. Inside a Compose network use `http://rustfs:9000`; from the host use `http://localhost:9000`. +Der `endpoint` muss von dem Rechner aus erreichbar sein, auf dem Terraform läuft. Im Compose-Netzwerk verwenden Sie `http://rustfs:9000`, vom Host aus `http://localhost:9000`. -### "Bucket cannot have ACLs set" or signature errors +### „Bucket cannot have ACLs set“ oder Signaturfehler -`skip_credentials_validation`, `skip_region_validation`, `skip_metadata_api_check`, `skip_requesting_account_id`, `force_path_style`, and `insecure` are all required for a non-AWS endpoint; missing any of them makes the backend talk to AWS defaults instead of RustFS. +`skip_credentials_validation`, `skip_region_validation`, `skip_metadata_api_check`, `skip_requesting_account_id`, `force_path_style` und `insecure` sind für einen Nicht-AWS-Endpunkt alle erforderlich. Fehlt eine davon, spricht das Backend die AWS-Standardwerte an statt RustFS. -### The state does not appear in the bucket +### Der State erscheint nicht im Bucket -Confirm that the bucket exists and that the credentials match the RustFS credentials. The state object appears under the `key` path (`rustfs-demo/terraform.tfstate` in this guide) after the first `init` or `apply`. +Stellen Sie sicher, dass der Bucket existiert und die Zugangsdaten mit den RustFS-Zugangsdaten übereinstimmen. Das State-Objekt erscheint nach dem ersten `init` oder `apply` unter dem Pfad `key` (in dieser Anleitung `rustfs-demo/terraform.tfstate`). -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional S3 operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Terraform S3 backend documentation](https://developer.hashicorp.com/terraform/language/backend/s3) for options such as workspace prefixes and role assumption. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Dokumentation zum Terraform-S3-Backend](https://developer.hashicorp.com/terraform/language/backend/s3) für Optionen wie Workspace-Präfixe und die Annahme von Rollen. diff --git a/content/de/developer/integration/observability/fluentd.md b/content/de/developer/integration/observability/fluentd.md index 4607c0ec3..90efdbd8b 100644 --- a/content/de/developer/integration/observability/fluentd.md +++ b/content/de/developer/integration/observability/fluentd.md @@ -1,13 +1,13 @@ --- title: "Fluentd" -description: "Ship Fluentd log events to RustFS with the S3 output plugin." +description: "Senden Sie Fluentd-Log-Ereignisse mit dem S3-Output-Plugin an RustFS." --- -This guide connects [Fluentd](https://github.com/fluent/fluentd) — the open-source data collector — to **RustFS** through the `out_s3` output plugin. You will run Fluentd with a tail source, buffer log events, and verify that the flushed objects are stored in RustFS. The workflow was verified with `fluent/fluentd:v1.17-1`, `fluent-plugin-s3` 1.8.6, and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Fluentd](https://github.com/fluent/fluentd) — den Open-Source-Datensammler — über das Output-Plugin `out_s3` mit **RustFS**. Sie betreiben Fluentd mit einer Tail-Quelle, puffern Log-Ereignisse und prüfen, dass die geschriebenen Objekte in RustFS liegen. Der Ablauf wurde mit `fluent/fluentd:v1.17-1`, `fluent-plugin-s3` 1.8.6 und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,18 +16,18 @@ flowchart LR Fluentd -->|"gzip objects"| RustFS["RustFS :9000"] ``` -The tail source reads new lines from `app.log` and hands them to the S3 output, which buffers events on a time key and uploads a gzip object per flush window. +Die Tail-Quelle liest neue Zeilen aus `app.log` und übergibt sie an die S3-Ausgabe. Diese puffert Ereignisse über einen Zeit-Schlüssel und lädt pro Flush-Fenster ein gzip-Objekt hoch. -## 1. Create the project files +## 1. Projektdateien anlegen -Create the bucket first — Fluentd does not create buckets: +Legen Sie zuerst den Bucket an. Fluentd legt keine Buckets an: ```bash rc alias set rustfs http://:9000 rc mb rustfs/fluentd-data ``` -The official Fluentd image runs as a non-root user and cannot install gems at startup, so build a small image with the S3 plugin: +Das offizielle Fluentd-Image läuft als Benutzer ohne Root-Rechte und kann beim Start keine Gems installieren. Bauen Sie daher ein kleines Image mit dem S3-Plugin: ```dockerfile title="Dockerfile" FROM fluent/fluentd:v1.17-1 @@ -36,7 +36,7 @@ RUN gem install fluent-plugin-s3 --no-document USER fluent ``` -Create the Fluentd configuration, replacing both credential placeholders: +Erstellen Sie die Fluentd-Konfiguration und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```nginx title="fluent.conf" @@ -67,9 +67,9 @@ Create the Fluentd configuration, replacing both credential placeholders: ``` -`force_path_style true` is required — without it the plugin constructs `fluentd-data.rustfs` as a hostname and every request fails with a DNS error. Inside the Compose network the hostname is `rustfs`; from the host use `http://localhost:9000/`. +`force_path_style true` erzwingt pfadbasierte Adressierung (Path-Style) und ist erforderlich. Ohne diese Einstellung setzt das Plugin den Hostnamen `fluentd-data.rustfs` zusammen, und jede Anfrage scheitert mit einem DNS-Fehler. Im Compose-Netzwerk lautet der Hostname `rustfs`; vom Host aus verwenden Sie `http://localhost:9000/`. -Build the image and start Fluentd on the same Docker network as RustFS: +Bauen Sie das Image und starten Sie Fluentd im selben Docker-Netzwerk wie RustFS: ```bash docker build -t fluentd-rustfs . @@ -79,74 +79,74 @@ docker run -d --name fluentd --network oo-rustfs_default \ -v "$PWD/logs":/var/log fluentd-rustfs ``` -## 2. Produce log events +## 2. Log-Ereignisse erzeugen -Append lines to the watched file: +Hängen Sie Zeilen an die überwachte Datei an: ```bash echo "rustfs fluentd demo line 1" >> logs/app.log echo "rustfs fluentd demo line 2" >> logs/app.log ``` -With a 30-second time key and immediate flush mode, each window uploads one gzip object shortly after it closes. Wait about a minute. +Bei einem Zeit-Schlüssel von 30 Sekunden und sofortigem Flush lädt jedes Fenster kurz nach dem Schließen ein gzip-Objekt hoch. Warten Sie etwa eine Minute. -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/fluentd-data/ -r ``` -Each flush window produces one gzipped object: +Jedes Flush-Fenster erzeugt ein gzip-komprimiertes Objekt: ```text fluentd-logs20260921154400_0.gz fluentd-logs20260921154400_1.gz ``` -Read one object back to confirm the events are intact: +Lesen Sie ein Objekt zurück, um zu prüfen, dass die Ereignisse unversehrt sind: ```bash rc cat rustfs/fluentd-data/fluentd-logs20260921154400_0.gz | gunzip ``` -![Fluentd log objects stored in the RustFS Console](./images/rustfs-fluentd-logs.png) +![In der RustFS Console gespeicherte Fluentd-Log-Objekte](./images/rustfs-fluentd-logs.png) -## 4. Stop or reset the deployment +## 4. Bereitstellung anhalten oder zurücksetzen -Stop Fluentd while keeping the data: +Stoppen Sie Fluentd und behalten Sie die Daten: ```bash docker rm -f fluentd ``` -The objects stay in the `fluentd-data` bucket. To delete them, remove the bucket: +Die Objekte bleiben im Bucket `fluentd-data`. Um sie zu löschen, entfernen Sie den Bucket: ```bash rc rb rustfs/fluentd-data --force ``` -## Troubleshooting +## Fehlerbehebung ### `Unknown output plugin 's3'` -The plugin is not installed. Confirm the Dockerfile installs `fluent-plugin-s3` as `root` before switching back to the `fluent` user — installing at container start as the default user fails with permission errors. +Das Plugin ist nicht installiert. Stellen Sie sicher, dass das Dockerfile `fluent-plugin-s3` als `root` installiert, bevor es zum Benutzer `fluent` zurückwechselt. Eine Installation beim Containerstart als Standardbenutzer scheitert mit Berechtigungsfehlern. ### `Failed to open TCP connection to fluentd-data.rustfs` -Virtual-hosted addressing is in use. Add `force_path_style true` to the `s3` output so the bucket stays in the URL path. +Es wird Adressierung im Virtual-Hosted-Stil verwendet. Fügen Sie `force_path_style true` zur Ausgabe `s3` hinzu, damit der Bucket im URL-Pfad bleibt. -### The worker crashes in a restart loop +### Der Worker stürzt in einer Neustartschleife ab -The output fails hard when the bucket does not exist. Create `fluentd-data` before starting Fluentd and check the startup log: +Die Ausgabe schlägt fehl, sobald der Bucket nicht existiert. Legen Sie `fluentd-data` an, bevor Sie Fluentd starten, und prüfen Sie das Startprotokoll: ```bash docker logs fluentd | grep -iE "error|bucket" | tail ``` -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Fluentd outputs. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [fluent-plugin-s3 documentation](https://github.com/fluent/fluent-plugin-s3) for object key formats and compression options. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Fluentd-Ausgaben verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Dokumentation zu fluent-plugin-s3](https://github.com/fluent/fluent-plugin-s3) für Objektschlüssel-Formate und Komprimierungsoptionen. diff --git a/content/de/developer/integration/observability/greptimedb.md b/content/de/developer/integration/observability/greptimedb.md index 5b7ee6905..f03819a15 100644 --- a/content/de/developer/integration/observability/greptimedb.md +++ b/content/de/developer/integration/observability/greptimedb.md @@ -1,13 +1,13 @@ --- title: "GreptimeDB" -description: "Run GreptimeDB with RustFS as the S3-compatible object storage backend." +description: "Betreiben Sie GreptimeDB mit RustFS als S3-kompatiblem Objektspeicher-Backend." --- -This guide connects [GreptimeDB](https://github.com/GreptimeTeam/greptimedb) — the open-source, cloud-native time-series database — to **RustFS** as its object storage backend. You will start a standalone instance with its `[storage]` section pointed at a RustFS bucket, write time-series rows through the SQL API, and confirm the Parquet files and manifests in the bucket. The workflow was verified with `greptime/greptimedb` (main, commit `179ff8e5`) against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [GreptimeDB](https://github.com/GreptimeTeam/greptimedb) — die quelloffene, cloud-native Zeitreihendatenbank — mit **RustFS** als Objektspeicher-Backend. Sie starten eine Standalone-Instanz, deren Abschnitt `[storage]` auf einen RustFS-Bucket zeigt, schreiben Zeitreihenzeilen über die SQL-API und prüfen die Parquet-Dateien und Manifeste im Bucket. Der Ablauf wurde mit `greptime/greptimedb` (main, Commit `179ff8e5`) gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker, or a local GreptimeDB binary. This deployment is intended for local integration testing, not production. +Sie benötigen Docker oder eine lokale GreptimeDB-Binärdatei. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR DB -->|"SST + manifests"| RustFS["RustFS :9000"] ``` -GreptimeDB keeps its write-ahead log and recent data locally, then persists SSTables (Parquet) and table manifests to object storage. Pointing the storage backend at RustFS makes the bucket the durable home of all table data. +GreptimeDB hält das Write-Ahead-Log und die jüngsten Daten lokal und persistiert anschließend SSTables (Parquet) und Tabellen-Manifeste im Objektspeicher. Wenn das Speicher-Backend auf RustFS zeigt, ist der Bucket der dauerhafte Speicherort aller Tabellendaten. -## 1. Configure the storage backend +## 1. Speicher-Backend konfigurieren -Create the bucket and a config file with an S3 storage section, replacing all connection placeholders: +Legen Sie den Bucket und eine Konfigurationsdatei mit einem S3-Speicherabschnitt an. Ersetzen Sie alle Verbindungsplatzhalter: ```toml title="greptimedb.toml" [storage] @@ -32,11 +32,11 @@ endpoint = "http://:9000" region = "us-east-1" ``` -GreptimeDB uses path-style requests for custom endpoints by default; virtual-hosted style must be opted into explicitly with `enable_virtual_host_style`, so no extra flag is needed for RustFS. +GreptimeDB verwendet für eigene Endpunkte standardmäßig Anfragen mit pfadbasierter Adressierung (Path-Style). Die Adressierung im Virtual-Hosted-Stil müssen Sie mit `enable_virtual_host_style` ausdrücklich aktivieren. Für RustFS ist daher kein zusätzliches Flag nötig. -## 2. Run GreptimeDB +## 2. GreptimeDB ausführen -Start a standalone instance with the config file: +Starten Sie eine Standalone-Instanz mit der Konfigurationsdatei: ```bash docker run -d --name greptimedb --network oo-rustfs_default -p 4000:4000 -p 4002:4002 \ @@ -47,11 +47,11 @@ docker run -d --name greptimedb --network oo-rustfs_default -p 4000:4000 -p 4002 --config-file /etc/greptimedb/greptimedb.toml ``` -Port `4000` serves the HTTP SQL endpoint and `4002` the MySQL protocol. +Port `4000` stellt den HTTP-SQL-Endpunkt bereit, Port `4002` das MySQL-Protokoll. -## 3. Write and query time series +## 3. Zeitreihen schreiben und abfragen -Create a table, insert rows, and read them back. The HTTP SQL endpoint takes form-encoded requests: +Legen Sie eine Tabelle an, fügen Sie Zeilen ein und lesen Sie sie zurück. Der HTTP-SQL-Endpunkt erwartet formularcodierte Anfragen: ```bash curl -s -X POST "http://localhost:4000/v1/sql" \ @@ -61,69 +61,72 @@ curl -s -X POST "http://localhost:4000/v1/sql" \ --data-urlencode "sql=INSERT INTO rustfs_demo VALUES (\"node-1\", 0.31, 0.62, 1790681000000), (\"node-1\", 0.35, 0.63, 1790681060000), (\"node-2\", 0.51, 0.71, 1790681000000)" ``` + ```text {"output":[{"affectedrows":3}],"execution_time_ms":2} ``` -Query the rows back: +Fragen Sie die Zeilen wieder ab: ```bash curl -s -X POST "http://localhost:4000/v1/sql" \ --data-urlencode "sql=SELECT * FROM rustfs_demo ORDER BY ts" ``` + ```text {"output":[{"records":{"rows":[["node-2",0.51,0.71,1790681000000],["node-1",0.35,0.63,1790681060000]],"total_rows":2}}]} ``` -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen -List the bucket — after the memtable flushes, the bucket holds Parquet SSTables and JSON manifests: +Listen Sie den Bucket auf. Nach dem Leeren der Memtable enthält der Bucket Parquet-SSTables und JSON-Manifeste: ```bash rc ls rustfs// -r ``` + ```text greptimedb/data/greptime/public/1024/1024_0000000000/manifest/00000000000000000000.json greptimedb/data/greptime/greptime_private/1025/1025_0000000000/b11e8b25-5763-4f05-bcab-b6ee0a756a69.parquet greptimedb/data/greptime/greptime_private/1025/1025_0000000000/manifest/00000000000000000001.json ``` -Each database gets a directory under `data/`, and per-region `manifest/*.json` files describe the SSTables GreptimeDB reads back during queries. +Jede Datenbank erhält ein Verzeichnis unter `data/`, und die Dateien `manifest/*.json` je Region beschreiben die SSTables, die GreptimeDB bei Abfragen wieder liest. -![GreptimeDB data stored in the RustFS Console](./images/rustfs-greptimedb-data.png) +![In der RustFS Console gespeicherte GreptimeDB-Daten](./images/rustfs-greptimedb-data.png) -## 5. Stop or reset +## 5. Anhalten oder zurücksetzen -To tear down the demo while keeping the bucket objects: +So bauen Sie die Demo ab und behalten die Objekte im Bucket: ```bash docker rm -f greptimedb ``` -To delete the stored data: +So löschen Sie die gespeicherten Daten: ```bash rc rm rustfs// --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `Form requests must have Content-Type: application/x-www-form-urlencoded` -The `/v1/sql` HTTP endpoint only accepts form-encoded bodies. Pass SQL with `curl --data-urlencode "sql=..."` (or `application/x-www-form-urlencoded`), not as a JSON body. +Der HTTP-Endpunkt `/v1/sql` akzeptiert nur formularcodierte Inhalte. Übergeben Sie SQL mit `curl --data-urlencode "sql=..."` (oder `application/x-www-form-urlencoded`), nicht als JSON-Body. -### Bucket stays empty +### Der Bucket bleibt leer -GreptimeDB flushes memtables to object storage asynchronously. Run a few more inserts and wait a few seconds, or trigger a manual flush, then list the bucket again. +GreptimeDB schreibt Memtables asynchron in den Objektspeicher. Führen Sie einige weitere Inserts aus und warten Sie einige Sekunden, oder lösen Sie einen manuellen Flush aus, und listen Sie den Bucket danach erneut auf. -### Startup fails with an S3 error +### Der Start schlägt mit einem S3-Fehler fehl -Confirm `endpoint` includes the scheme, the bucket exists, and `access_key_id`/`secret_access_key` match a RustFS access key. The `root` value is optional but keeps the table tree under a known prefix. +Stellen Sie sicher, dass `endpoint` das Schema enthält, der Bucket existiert und `access_key_id` sowie `secret_access_key` mit einem RustFS-Zugriffsschlüsselpaar übereinstimmen. Der Wert `root` ist optional, hält den Tabellenbaum aber unter einem bekannten Präfix. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional GreptimeDB storage options. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [GreptimeDB configuration reference](https://docs.greptime.com/operational-guide/configure/configure-datanode/) to tune flush intervals and cache layers for production workloads. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere GreptimeDB-Speicheroptionen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [GreptimeDB-Konfigurationsreferenz](https://docs.greptime.com/operational-guide/configure/configure-datanode/), um Flush-Intervalle und Cache-Schichten für Produktivlasten abzustimmen. diff --git a/content/de/developer/integration/observability/loki.md b/content/de/developer/integration/observability/loki.md index f15efac41..2980afd74 100644 --- a/content/de/developer/integration/observability/loki.md +++ b/content/de/developer/integration/observability/loki.md @@ -248,9 +248,9 @@ docker compose run --rm --entrypoint /bin/sh create-bucket -c \ [2026-09-20 14:49:33] 670 B fake/cd916b27d004a688/1a0bf4a03ca:1a0bf4a4e03:1376b308 ``` -Sie können das Präfix auch in der RustFS-Konsole anzeigen: +Sie können das Präfix auch in der RustFS Console anzeigen: -![In der RustFS-Konsole gespeicherte Loki-Log-Chunks](./images/rustfs-loki-chunks.png) +![In der RustFS Console gespeicherte Loki-Log-Chunks](./images/rustfs-loki-chunks.png) ## 6. Stack stoppen oder zurücksetzen @@ -290,6 +290,6 @@ docker compose logs create-bucket ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [Grafana-Loki-Dokumentation](https://grafana.com/docs/loki/latest/), um Promtail, Alloy oder den OpenTelemetry Collector als Log-Producer anzubinden. diff --git a/content/de/developer/integration/observability/openobserve.md b/content/de/developer/integration/observability/openobserve.md index e89f41e99..673ba1e68 100644 --- a/content/de/developer/integration/observability/openobserve.md +++ b/content/de/developer/integration/observability/openobserve.md @@ -164,7 +164,7 @@ Der Dienst `init-bucket` sollte nach dem Anlegen des Buckets mit dem Exit-Code ` ✓ Bucket 'rustfs/my-bucket' created successfully. ``` -Öffnen Sie die OpenObserve-Oberfläche unter `http://localhost:5080` und melden Sie sich mit den Werten `ZO_ROOT_USER_EMAIL` und `ZO_ROOT_USER_PASSWORD` aus `.env` an. Die RustFS-Konsole erreichen Sie unter `http://localhost:9001/rustfs/console/`. +Öffnen Sie die OpenObserve-Oberfläche unter `http://localhost:5080` und melden Sie sich mit den Werten `ZO_ROOT_USER_EMAIL` und `ZO_ROOT_USER_PASSWORD` aus `.env` an. Die RustFS Console erreichen Sie unter `http://localhost:9001/rustfs/console/`. ### 3. Verbindung zwischen OpenObserve und RustFS bestätigen @@ -229,13 +229,13 @@ Die Ausgabe sollte die Prüfdatei und die Ingester-Ausgabe unterhalb von `files/ 6.5 KiB files/default/index/rustfs_test_logs/2026/09/20/02/75072592621841940484907.ttv ``` -Sie können den Bucket auch in der RustFS-Konsole unter `http://localhost:9001/rustfs/console/` anzeigen: +Sie können den Bucket auch in der RustFS Console unter `http://localhost:9001/rustfs/console/` anzeigen: -![Der Bucket my-bucket in der RustFS-Konsole](./images/rustfs-bucket-list.png) +![Der Bucket my-bucket in der RustFS Console](./images/rustfs-bucket-list.png) OpenObserve speichert Parquet-Datendateien unterhalb von `files////` und Volltextindex-Dateien unterhalb von `files//index/`: -![Von OpenObserve geschriebene Parquet-Datei in der RustFS-Konsole](./images/rustfs-parquet-objects.png) +![Von OpenObserve geschriebene Parquet-Datei in der RustFS Console](./images/rustfs-parquet-objects.png) ### Logs in OpenObserve abfragen @@ -296,9 +296,9 @@ docker compose logs openobserve | grep "INGESTER:JOB" OpenObserve v1.0.x lehnt `ZO_ROOT_USER_PASSWORD`-Werte ab, die nicht mindestens einen Großbuchstaben, einen Kleinbuchstaben, eine Ziffer und ein Sonderzeichen enthalten. -### Die RustFS-Konsole öffnet sich nicht +### Die RustFS Console öffnet sich nicht -In RustFS v2.x wird die Konsole unter dem Pfadpräfix `/rustfs/console/` bereitgestellt. Eine Anfrage an den Root-Pfad von Port `9001` liefert eine S3-ähnliche XML-Antwort mit Zugriffsverweigerung — das ist erwartetes Verhalten. +In RustFS v2.x wird die Console unter dem Pfadpräfix `/rustfs/console/` bereitgestellt. Eine Anfrage an den Root-Pfad von Port `9001` liefert eine S3-ähnliche XML-Antwort mit Zugriffsverweigerung — das ist erwartetes Verhalten. ### RustFS startet mit einem Berechtigungsfehler nicht @@ -306,6 +306,6 @@ Das RustFS-Image läuft mit Benutzer und Gruppe `10001`. Wenn Sie statt des Name ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [OpenObserve-Dokumentation](https://openobserve.ai/docs/), um echte Log-Producer wie Fluent Bit oder den OpenTelemetry Collector anzubinden. diff --git a/content/de/developer/integration/observability/opentelemetry.md b/content/de/developer/integration/observability/opentelemetry.md index 283df4135..566ad5a84 100644 --- a/content/de/developer/integration/observability/opentelemetry.md +++ b/content/de/developer/integration/observability/opentelemetry.md @@ -1,13 +1,13 @@ --- title: "OpenTelemetry" -description: "Export OpenTelemetry Collector logs to RustFS with the AWS S3 exporter." +description: "Exportieren Sie Logs des OpenTelemetry Collectors mit dem AWS-S3-Exporter nach RustFS." --- -This guide connects the [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/) — the CNCF telemetry pipeline — to **RustFS** through the collector's `awss3` exporter. You will run the contrib collector with a `filelog` receiver, ship the log lines of a file into the `otel-data` bucket, and verify the partitioned objects in RustFS. The workflow was verified with `otel/opentelemetry-collector-contrib:0.138.0` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie den [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/) — die Telemetrie-Pipeline der CNCF — über den Exporter `awss3` des Collectors mit **RustFS**. Sie betreiben den Contrib-Collector mit einem Empfänger `filelog`, übertragen die Zeilen einer Datei in den Bucket `otel-data` und prüfen die partitionierten Objekte in RustFS. Der Ablauf wurde mit `otel/opentelemetry-collector-contrib:0.138.0` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,18 +15,18 @@ flowchart LR Collector -->|awss3| RustFS["RustFS :9000"] ``` -The `filelog` receiver tails the log file and the `awss3` exporter uploads batches to the bucket, partitioned into time-based prefixes. Metrics and traces can be routed through the same exporter with their own pipelines. +Der Empfänger `filelog` liest die Logdatei fortlaufend, und der Exporter `awss3` lädt Stapel in den Bucket hoch, aufgeteilt in zeitbasierte Präfixe. Metriken und Traces können über denselben Exporter mit eigenen Pipelines geleitet werden. -## 1. Create the project files +## 1. Projektdateien anlegen -Create the bucket first — the exporter does not create buckets: +Legen Sie zuerst den Bucket an. Der Exporter legt keine Buckets an: ```bash rc alias set rustfs http://:9000 rc mb rustfs/otel-data ``` -Create the collector configuration, replacing both credential placeholders: +Erstellen Sie die Collector-Konfiguration und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```yaml title="config.yaml" receivers: @@ -52,9 +52,9 @@ service: exporters: [awss3] ``` -The exporter reads credentials from the standard `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, and `AWS_REGION` environment variables. `marshaler: body` writes each log line as plain text; omit it to store OTLP JSON instead. `s3_force_path_style` and `disable_ssl` are required for a plain-HTTP, non-AWS endpoint. +Der Exporter liest die Zugangsdaten aus den Standard-Umgebungsvariablen `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `AWS_REGION`. `marshaler: body` schreibt jede Logzeile als einfachen Text. Lassen Sie die Einstellung weg, um stattdessen OTLP-JSON zu speichern. `s3_force_path_style` erzwingt pfadbasierte Adressierung (Path-Style). Zusammen mit `disable_ssl` ist das für einen Endpunkt mit unverschlüsseltem HTTP außerhalb von AWS erforderlich. -Create the Compose file: +Erstellen Sie die Compose-Datei: ```yaml title="compose.yaml" services: @@ -75,9 +75,9 @@ networks: otel: ``` -## 2. Start the collector and produce logs +## 2. Collector starten und Logs erzeugen -Start the stack and append lines to the watched file: +Starten Sie den Stack und hängen Sie Zeilen an die überwachte Datei an: ```bash echo "otel demo log line one" > app.log @@ -85,61 +85,62 @@ docker compose up -d echo "second line after start" >> app.log ``` -The collector tails the file from the beginning and uploads each buffer when the partition rolls over, so allow about a minute after the last line before checking. +Der Collector liest die Datei von Anfang an und lädt jeden Puffer hoch, wenn die Partition wechselt. Warten Sie nach der letzten Zeile etwa eine Minute, bevor Sie prüfen. -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/otel-data/ -r ``` -Log records are uploaded under time-based partitions with the configured file prefix: +Log-Datensätze werden unter zeitbasierten Partitionen mit dem konfigurierten Dateipräfix hochgeladen: ```text year=2026/month=09/day=21/hour=15/minute=53/logs/applogs_288361608.txt ``` -Read one object back to confirm the lines arrived intact: +Lesen Sie ein Objekt zurück, um zu prüfen, dass die Zeilen unversehrt angekommen sind: ```bash rc cat rustfs/otel-data/year=2026/month=09/day=21/hour=15/minute=53/logs/applogs_288361608.txt ``` + ```text otel demo log line one second line after start ``` -![OpenTelemetry log objects stored in the RustFS Console](./images/rustfs-otel-logs.png) +![In der RustFS Console gespeicherte OpenTelemetry-Log-Objekte](./images/rustfs-otel-logs.png) -## 4. Stop or reset the deployment +## 4. Bereitstellung anhalten oder zurücksetzen -Stop the collector while keeping the data: +Stoppen Sie den Collector und behalten Sie die Daten: ```bash docker compose down ``` -The objects stay in the `otel-data` bucket. To delete them, remove the bucket: +Die Objekte bleiben im Bucket `otel-data`. Um sie zu löschen, entfernen Sie den Bucket: ```bash rc rb rustfs/otel-data --force ``` -## Troubleshooting +## Fehlerbehebung -### `has invalid keys` when the collector starts +### `has invalid keys` beim Start des Collectors -The `awss3` exporter schema differs between collector releases. Version 0.138 nests the upload settings under `s3uploader` as shown above; the endpoint key is `endpoint` (not `s3_endpoint`). Newer releases move these keys to the top level — check the README for your exact collector version. +Das Schema des Exporters `awss3` unterscheidet sich zwischen Collector-Versionen. Version 0.138 verschachtelt die Upload-Einstellungen unter `s3uploader`, wie oben gezeigt. Der Schlüssel für den Endpunkt heißt `endpoint` (nicht `s3_endpoint`). Neuere Versionen verschieben diese Schlüssel auf die oberste Ebene. Prüfen Sie die README Ihrer Collector-Version. -### Nothing appears in the bucket +### Im Bucket erscheint nichts -Confirm the credentials environment variables are set on the collector container, that `s3_force_path_style` is `true`, and that the exporter can reach `http://rustfs:9000` from inside the Compose network. Enable the `debug` exporter on the same pipeline to see whether records flow at all. +Stellen Sie sicher, dass die Umgebungsvariablen für die Zugangsdaten am Collector-Container gesetzt sind, dass `s3_force_path_style` den Wert `true` hat und dass der Exporter `http://rustfs:9000` aus dem Compose-Netzwerk erreichen kann. Schalten Sie den Exporter `debug` auf derselben Pipeline hinzu, um zu sehen, ob überhaupt Datensätze fließen. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional collector operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [AWS S3 exporter documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/awss3exporter) to add metrics and traces pipelines. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Collector-Operationen verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Dokumentation zum AWS-S3-Exporter](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/awss3exporter), um Pipelines für Metriken und Traces hinzuzufügen. diff --git a/content/de/developer/integration/observability/tempo.md b/content/de/developer/integration/observability/tempo.md index 3c5e5393e..113ccb281 100644 --- a/content/de/developer/integration/observability/tempo.md +++ b/content/de/developer/integration/observability/tempo.md @@ -240,9 +240,9 @@ docker compose run --rm --entrypoint /bin/sh create-bucket -c \ [2026-09-20 15:03:54] 25.16 KiB single-tenant/619118dc-a512-4ca6-90f5-e8b15bc9013f/data.parquet ``` -Sie können das Präfix auch in der RustFS-Konsole anzeigen: +Sie können das Präfix auch in der RustFS Console anzeigen: -![Der in der RustFS-Konsole gespeicherte Tempo-Trace-Block](./images/rustfs-tempo-blocks.png) +![Der in der RustFS Console gespeicherte Tempo-Trace-Block](./images/rustfs-tempo-blocks.png) Da der Block in RustFS liegt, bleibt der Trace über Tempo-Neustarts hinweg abfragbar — starten Sie den Container neu und wiederholen Sie die Suche zur Bestätigung. @@ -288,6 +288,6 @@ docker compose logs create-bucket ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [Grafana-Tempo-Dokumentation](https://grafana.com/docs/tempo/latest/), um den OpenTelemetry Collector oder instrumentierte Anwendungen als Trace-Producer anzubinden. diff --git a/content/de/developer/integration/observability/thanos.md b/content/de/developer/integration/observability/thanos.md index 856c31db6..99135cb79 100644 --- a/content/de/developer/integration/observability/thanos.md +++ b/content/de/developer/integration/observability/thanos.md @@ -1,13 +1,13 @@ --- title: "Thanos" -description: "Run Thanos with RustFS as the S3 object storage backend for Prometheus blocks, deployed with Docker Compose." +description: "Betreiben Sie Thanos mit RustFS als S3-Objektspeicher-Backend für Prometheus-Blöcke, bereitgestellt mit Docker Compose." --- -This guide connects [Thanos](https://github.com/thanos-io/thanos) — the highly available Prometheus setup with long-term storage — to **RustFS** as its object store. You will run Prometheus with a Thanos sidecar that uploads TSDB blocks to RustFS, then query the historical data back through a Store Gateway and a Query frontend. The workflow was verified with `thanosio/thanos:v0.37.2`, `prom/prometheus:v2.53.1`, and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Thanos](https://github.com/thanos-io/thanos) — die hochverfügbare Prometheus-Einrichtung mit Langzeitspeicher — mit **RustFS** als Objektspeicher. Sie betreiben Prometheus mit einem Thanos-Sidecar, der TSDB-Blöcke nach RustFS hochlädt, und fragen die historischen Daten anschließend über ein Store Gateway und ein Query-Frontend ab. Der Ablauf wurde mit `thanosio/thanos:v0.37.2`, `prom/prometheus:v2.53.1` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker with the Compose plugin. This deployment is intended for local integration testing, not production. +Sie benötigen Docker mit dem Compose-Plugin. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -18,27 +18,27 @@ flowchart LR Query -->|gRPC| Store ``` -The sidecar watches the Prometheus TSDB directory and uploads every two-hour block to the `thanos-data` bucket in RustFS. The Store Gateway reads the same bucket and answers queries about historical blocks, so Query resolves both live data through the sidecar and old data through the Store Gateway. +Der Sidecar beobachtet das Prometheus-TSDB-Verzeichnis und lädt jeden Zwei-Stunden-Block in den Bucket `thanos-data` in RustFS hoch. Das Store Gateway liest denselben Bucket und beantwortet Abfragen zu historischen Blöcken. Query bezieht damit sowohl die Live-Daten über den Sidecar als auch die älteren Daten über das Store Gateway. -## 1. Create the project files +## 1. Projektdateien anlegen -Create a working directory: +Erstellen Sie ein Arbeitsverzeichnis: ```bash mkdir rustfs-thanos cd rustfs-thanos ``` -Create an environment file and replace both credential placeholders: +Erstellen Sie eine Umgebungsdatei und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Use dedicated credentials for the `thanos-data` bucket. Do not commit `.env` to source control. +Verwenden Sie dedizierte Zugangsdaten für den Bucket `thanos-data`. Nehmen Sie `.env` nicht in die Versionsverwaltung auf. -Create the Prometheus configuration with an external label — Thanos requires it to deduplicate blocks: +Erstellen Sie die Prometheus-Konfiguration mit einem externen Label. Thanos benötigt es, um Blöcke zu deduplizieren: ```yaml title="prometheus.yml" global: @@ -56,7 +56,7 @@ scrape_configs: - targets: ["rustfs:9000"] ``` -Create the Thanos object store configuration: +Erstellen Sie die Objektspeicher-Konfiguration von Thanos: ```yaml title="bucket.yml" type: S3 @@ -68,13 +68,13 @@ config: insecure: true ``` -Thanos does not interpolate `.env` files itself. Before starting the stack, replace the placeholders with the same values you set in `.env`: +Thanos interpoliert `.env`-Dateien nicht selbst. Ersetzen Sie die Platzhalter vor dem Start des Stacks durch dieselben Werte wie in `.env`: ```bash sed -i.bak "s|\${RUSTFS_ACCESS_KEY}|$(grep RUSTFS_ACCESS_KEY .env | cut -d= -f2)|;s|\${RUSTFS_SECRET_KEY}|$(grep RUSTFS_SECRET_KEY .env | cut -d= -f2)|" bucket.yml ``` -Create the Compose file: +Erstellen Sie die Compose-Datei: ```yaml title="compose.yaml" services: @@ -189,47 +189,47 @@ volumes: store-data: ``` -The `--storage.tsdb.min-block-duration` and `--storage.tsdb.max-block-duration` flags disable Prometheus compaction. The sidecar refuses to ship blocks from a compacting TSDB because the local blocks would no longer match the uploaded ones. +Die Flags `--storage.tsdb.min-block-duration` und `--storage.tsdb.max-block-duration` deaktivieren die Prometheus-Kompaktierung. Der Sidecar überträgt keine Blöcke aus einer kompaktierenden TSDB, weil die lokalen Blöcke dann nicht mehr zu den hochgeladenen passen würden. -## 2. Validate and start the deployment +## 2. Bereitstellung prüfen und starten -Resolve the Compose file before starting containers: +Prüfen Sie die Compose-Datei, bevor Sie Container starten: ```bash docker compose config ``` -Start the stack and wait until the sidecar reports itself ready: +Starten Sie den Stack und warten Sie, bis der Sidecar sich als bereit meldet: ```bash docker compose up -d docker compose logs sidecar | grep -m1 "status=ready" ``` -Check that the sidecar picked up the Prometheus external labels: +Prüfen Sie, dass der Sidecar die externen Labels von Prometheus übernommen hat: ```bash docker compose logs sidecar | grep "external labels" ``` -The Thanos Query UI answers on `http://localhost:9091`, and the RustFS Console runs at `http://localhost:9001`. +Die Thanos-Query-Oberfläche antwortet unter `http://localhost:9091`, die RustFS Console (Weboberfläche) läuft unter `http://localhost:9001`. -## 3. Upload a block to RustFS +## 3. Block nach RustFS hochladen -The sidecar uploads a block when Prometheus compacts one, which happens at a two-hour block boundary. To produce a block immediately, snapshot the TSDB through the admin API — with compaction disabled, the sidecar ships the head-block snapshot directly: +Der Sidecar lädt einen Block hoch, wenn Prometheus einen kompaktiert. Das geschieht an einer Blockgrenze von zwei Stunden. Um sofort einen Block zu erzeugen, erstellen Sie einen Snapshot der TSDB über die Admin-API. Bei deaktivierter Kompaktierung liefert der Sidecar den Snapshot des Head-Blocks direkt aus: ```bash curl -s -XPOST http://localhost:9090/api/v1/admin/tsdb/snapshot | head -c 200 ``` -Wait for the upload, then check the shipper state inside Prometheus: +Warten Sie auf den Upload und prüfen Sie anschließend den Shipper-Zustand in Prometheus: ```bash sleep 60 docker compose exec prometheus cat /prometheus/thanos.shipper.json ``` -The `uploaded` list should contain a block ID: +Die Liste `uploaded` sollte eine Block-ID enthalten: ```json { @@ -240,15 +240,15 @@ The `uploaded` list should contain a block ID: } ``` -## 4. Query historical data from RustFS +## 4. Historische Daten aus RustFS abfragen -The Store Gateway periodically syncs the bucket. Confirm it downloaded the uploaded block: +Das Store Gateway synchronisiert den Bucket regelmäßig. Prüfen Sie, dass es den hochgeladenen Block heruntergeladen hat: ```bash docker compose logs store | grep "loaded new block" ``` -Query a series through the Query frontend over the block's time range: +Fragen Sie eine Zeitreihe über das Query-Frontend im Zeitbereich des Blocks ab: ```bash START=$(date -u -d '2 hours ago' +%s) @@ -256,17 +256,17 @@ END=$(date -u +%s) curl -s "http://localhost:9091/api/v1/query_range?query=up%7Bjob%3D%22prometheus%22%7D&start=$START&end=$END&step=30" | head -c 300 ``` -The Store Gateway serves the response from the blocks it downloaded from RustFS, while the sidecar answers for the live head — both paths resolve through the same Query endpoint. +Das Store Gateway liefert die Antwort aus den Blöcken, die es aus RustFS heruntergeladen hat. Der Sidecar beantwortet den Live-Head. Beide Pfade laufen über denselben Query-Endpunkt. -## 5. Verify objects in RustFS +## 5. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash docker compose exec rustfs /usr/bin/rc ls local/thanos-data/ -r ``` -Each block is stored as three objects — the chunk files, the index, and `meta.json`: +Jeder Block wird als drei Objekte gespeichert: die Chunk-Dateien, der Index und `meta.json`: ```text 01M31EPTZC5E0SETZTP0SPFY79/chunks/000001 @@ -274,38 +274,38 @@ Each block is stored as three objects — the chunk files, the index, and `meta. 01M31EPTZC5E0SETZTP0SPFY79/meta.json ``` -![Thanos blocks stored in the RustFS Console](./images/rustfs-thanos-blocks.png) +![In der RustFS Console gespeicherte Thanos-Blöcke](./images/rustfs-thanos-blocks.png) -## 6. Stop or reset the deployment +## 6. Bereitstellung anhalten oder zurücksetzen -Stop the containers while keeping all data: +Stoppen Sie die Container und behalten Sie alle Daten: ```bash docker compose down ``` -The RustFS volume keeps the uploaded blocks, so the Store Gateway serves historical queries again after a restart. To delete everything, including the blocks in RustFS, add `--volumes`. +Das RustFS-Volume behält die hochgeladenen Blöcke, daher beantwortet das Store Gateway historische Abfragen nach einem Neustart erneut. Um alles zu löschen, einschließlich der Blöcke in RustFS, fügen Sie `--volumes` hinzu. -## Troubleshooting +## Fehlerbehebung -### The sidecar logs `Compaction needs to be disabled` +### Der Sidecar protokolliert `Compaction needs to be disabled` -Prometheus must run with `--storage.tsdb.min-block-duration` equal to `--storage.tsdb.max-block-duration` — set both to `2h` as shown in the Compose file. Otherwise the sidecar cannot guarantee that local blocks stay unchanged and refuses to upload. +Prometheus muss mit `--storage.tsdb.min-block-duration` gleich `--storage.tsdb.max-block-duration` laufen. Setzen Sie beide wie in der Compose-Datei auf `2h`. Andernfalls kann der Sidecar nicht garantieren, dass lokale Blöcke unverändert bleiben, und verweigert den Upload. ### `The specified bucket does not exist` -Thanos does not create buckets. Check that the `create-bucket` service completed successfully: +Thanos legt keine Buckets an. Prüfen Sie, dass der Dienst `create-bucket` erfolgreich abgeschlossen wurde: ```bash docker compose logs create-bucket ``` -### Queries return no historical data +### Abfragen liefern keine historischen Daten -Confirm that the Store Gateway has loaded at least one block (`docker compose logs store | grep "loaded new block"`) and that your query time range falls inside the uploaded block's window — check the block's `meta.json` in the RustFS Console for `minTime` and `maxTime`. +Stellen Sie sicher, dass das Store Gateway mindestens einen Block geladen hat (`docker compose logs store | grep "loaded new block"`) und dass der Zeitbereich Ihrer Abfrage im Fenster des hochgeladenen Blocks liegt. Prüfen Sie in `meta.json` des Blocks in der RustFS Console die Werte `minTime` und `maxTime`. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Thanos components. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Thanos documentation](https://thanos.io/tip/thanos/getting-started.md) to add Compactor, Ruler, or Receive for a production topology. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Thanos-Komponenten verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Thanos-Dokumentation](https://thanos.io/tip/thanos/getting-started.md), um Compactor, Ruler oder Receive für eine Produktivtopologie hinzuzufügen. diff --git a/content/de/developer/integration/observability/victoriametrics.md b/content/de/developer/integration/observability/victoriametrics.md index efc799d9a..cf9ec706f 100644 --- a/content/de/developer/integration/observability/victoriametrics.md +++ b/content/de/developer/integration/observability/victoriametrics.md @@ -1,13 +1,13 @@ --- title: "VictoriaMetrics" -description: "Back up VictoriaMetrics snapshots to RustFS with vmbackup." +description: "Sichern Sie VictoriaMetrics-Snapshots mit vmbackup in RustFS." --- -This guide connects [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics) — the Prometheus-compatible time-series database — to **RustFS** through `vmbackup` and `vmrestore`. You will run a single-node instance, import metrics, create an instant snapshot, back it up to a RustFS bucket, and restore the data into a fresh directory. The workflow was verified with `victoria-metrics`, `vmbackup`, and `vmrestore` v1.x images against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics) — die Prometheus-kompatible Zeitreihendatenbank — über `vmbackup` und `vmrestore` mit **RustFS**. Sie betreiben eine Einzelknoten-Instanz, importieren Metriken, erstellen einen sofortigen Snapshot, sichern ihn in einen RustFS-Bucket und stellen die Daten in einem neuen Verzeichnis wieder her. Der Ablauf wurde mit den Images `victoria-metrics`, `vmbackup` und `vmrestore` in Version v1.x gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -17,11 +17,11 @@ flowchart LR RustFS -->|"restore"| Restore["vmrestore"] ``` -`vmbackup` uploads a consistent point-in-time snapshot of the storage directory to any S3-compatible endpoint. `vmrestore` reverses the process, producing a data directory a VictoriaMetrics instance can open directly. +`vmbackup` lädt einen konsistenten Snapshot zu einem festen Zeitpunkt vom Speicherverzeichnis an jeden S3-kompatiblen Endpunkt hoch. `vmrestore` kehrt den Vorgang um und erzeugt ein Datenverzeichnis, das eine VictoriaMetrics-Instanz direkt öffnen kann. -## 1. Run VictoriaMetrics +## 1. VictoriaMetrics ausführen -Create the bucket and start a single-node instance: +Legen Sie den Bucket an und starten Sie eine Einzelknoten-Instanz: ```bash rc mb rustfs/vm-backups @@ -32,40 +32,42 @@ docker run -d --name vm --network oo-rustfs_default -p 8428:8428 \ -storageDataPath=/storage -retentionPeriod=100y ``` -## 2. Import metrics +## 2. Metriken importieren -Write a couple of samples through the Prometheus import API: +Schreiben Sie ein paar Beispielwerte über die Prometheus-Import-API: ```bash echo "vm_demo_metric 123" | curl -s --data-binary @- http://localhost:8428/api/v1/import/prometheus echo "vm_demo_metric 456" | curl -s --data-binary @- http://localhost:8428/api/v1/import/prometheus ``` -The endpoint answers `204 No Content`. Confirm the data is queryable: +Der Endpunkt antwortet mit `204 No Content`. Prüfen Sie, dass die Daten abfragbar sind: ```bash curl -s "http://localhost:8428/api/v1/export?match[]=vm_demo_metric" ``` + ```text {"metric":{"__name__":"vm_demo_metric"},"values":[123,456],"timestamps":[1790680894604,1790680894619]} ``` -## 3. Create a snapshot +## 3. Snapshot erstellen -Ask VictoriaMetrics for a consistent snapshot: +Fordern Sie bei VictoriaMetrics einen konsistenten Snapshot an: ```bash curl -s http://localhost:8428/snapshot/create ``` + ```text {"status":"ok","snapshot":"20260929112134-18D9C6C76704F913"} ``` -## 4. Back the snapshot up to RustFS +## 4. Snapshot nach RustFS sichern -Run `vmbackup` against the same storage volume, replacing the credential placeholders. The snapshot name comes from step 3: +Führen Sie `vmbackup` für dasselbe Speicher-Volume aus und ersetzen Sie die Platzhalter für die Zugangsdaten. Der Snapshot-Name stammt aus Schritt 3: ```bash docker run --rm --network oo-rustfs_default \ @@ -79,20 +81,22 @@ docker run --rm --network oo-rustfs_default \ -customS3Endpoint=http://:9000 ``` + ```text backup ... to S3{bucket: "vm-backups", dir: "demo/"} is complete; uploaded 760 bytes ``` -`-customS3Endpoint` redirects the AWS SDK to RustFS; custom endpoints are addressed with path-style requests automatically. Set `AWS_EC2_METADATA_DISABLED=true` on hosts without an EC2 metadata service to skip credential lookup delays. +`-customS3Endpoint` leitet das AWS SDK auf RustFS um. Eigene Endpunkte werden automatisch mit pfadbasierter Adressierung (Path-Style) angesprochen. Setzen Sie `AWS_EC2_METADATA_DISABLED=true` auf Hosts ohne EC2-Metadatendienst, um Verzögerungen bei der Suche nach Zugangsdaten zu überspringen. -## 5. Verify and restore +## 5. Prüfen und wiederherstellen -List the bucket prefix: +Listen Sie das Bucket-Präfix auf: ```bash rc ls rustfs/vm-backups/demo/ ``` + ```text backup_complete.ignore backup_metadata.ignore @@ -100,7 +104,7 @@ data/ metadata/ ``` -`backup_complete.ignore` marks a complete backup. Restore it into a fresh directory: +`backup_complete.ignore` kennzeichnet ein abgeschlossenes Backup. Stellen Sie es in einem neuen Verzeichnis wieder her: ```bash docker run --rm --network oo-rustfs_default \ @@ -113,45 +117,46 @@ docker run --rm --network oo-rustfs_default \ -customS3Endpoint=http://:9000 ``` + ```text restored 760 bytes from backup in 0.055 seconds ``` -The restored directory contains `data/`, `metadata/`, and a lock file — exactly what a VictoriaMetrics instance expects at `-storageDataPath`. +Das wiederhergestellte Verzeichnis enthält `data/`, `metadata/` und eine Lock-Datei. Genau das erwartet eine VictoriaMetrics-Instanz unter `-storageDataPath`. -![VictoriaMetrics backup stored in the RustFS Console](./images/rustfs-vm-backups.png) +![In der RustFS Console gespeichertes VictoriaMetrics-Backup](./images/rustfs-vm-backups.png) -## 6. Stop or reset +## 6. Anhalten oder zurücksetzen -To tear down the demo while keeping the bucket objects: +So bauen Sie die Demo ab und behalten die Objekte im Bucket: ```bash docker rm -f vm docker volume rm vm-data ``` -To delete the stored backups: +So löschen Sie die gespeicherten Backups: ```bash rc rm rustfs/vm-backups/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `vmbackup` hangs at startup or fails to find credentials +### `vmbackup` hängt beim Start oder findet keine Zugangsdaten -The AWS SDK probes the EC2 metadata service when environment credentials are absent. On machines without IMDS, export `AWS_EC2_METADATA_DISABLED=true` next to the key variables. +Das AWS SDK fragt den EC2-Metadatendienst ab, wenn keine Umgebungs-Zugangsdaten vorhanden sind. Exportieren Sie auf Rechnern ohne IMDS `AWS_EC2_METADATA_DISABLED=true` neben den Schlüsselvariablen. -### Backup parts re-upload on every run +### Backup-Teile werden bei jedem Lauf erneut hochgeladen -`vmbackup` performs incremental backups by comparing local and remote file hashes. Restoring to a fresh directory and running `vmbackup` from there re-uploads everything; keep the original data directory for incremental runs. +`vmbackup` führt inkrementelle Backups aus, indem es lokale und entfernte Datei-Hashes vergleicht. Wenn Sie in ein neues Verzeichnis wiederherstellen und `vmbackup` von dort ausführen, wird alles erneut hochgeladen. Behalten Sie das ursprüngliche Datenverzeichnis für inkrementelle Läufe. -### Query returns nothing right after import +### Die Abfrage liefert direkt nach dem Import nichts zurück -Imports are accepted asynchronously and the instant query endpoint can lag on a busy single node. Verify with `/api/v1/export` (or wait a few seconds) before creating the snapshot. +Importe werden asynchron angenommen, und der Endpunkt für Sofortabfragen kann auf einem ausgelasteten Einzelknoten nachlaufen. Prüfen Sie mit `/api/v1/export` (oder warten Sie einige Sekunden), bevor Sie den Snapshot erstellen. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional VictoriaMetrics components. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [vmbackup documentation](https://docs.victoriametrics.com/vmbackup/) to schedule backups and prune old snapshots. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere VictoriaMetrics-Komponenten verwenden. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [vmbackup-Dokumentation](https://docs.victoriametrics.com/vmbackup/), um Backups zu planen und alte Snapshots zu bereinigen. diff --git a/content/de/developer/integration/others/juicefs.md b/content/de/developer/integration/others/juicefs.md index 428b08cec..7014c3357 100644 --- a/content/de/developer/integration/others/juicefs.md +++ b/content/de/developer/integration/others/juicefs.md @@ -1,13 +1,13 @@ --- title: "JuiceFS" -description: "Build a POSIX filesystem on RustFS with JuiceFS S3 object storage." +description: "Bauen Sie mit JuiceFS und S3-Objektspeicher auf RustFS ein POSIX-Dateisystem." --- -This guide connects [JuiceFS](https://github.com/juicedata/juicefs) — the cloud-native distributed POSIX filesystem — to **RustFS** as its object storage backend. You will format a volume whose data chunks live in a RustFS bucket, mount it locally, and read and write files through the mount. The workflow was verified with `juicefs v1.3.1` (community edition, SQLite metadata engine) against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [JuiceFS](https://github.com/juicedata/juicefs) — das cloud-native verteilte POSIX-Dateisystem — mit **RustFS** als Objektspeicher-Backend. Sie formatieren ein Volume, dessen Daten-Chunks in einem RustFS-Bucket liegen, hängen es lokal ein und lesen und schreiben Dateien über den Mount. Der Ablauf wurde mit `juicefs v1.3.1` (Community Edition, SQLite-Metadaten-Engine) gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need the JuiceFS binary, a metadata engine, and FUSE (`fuse3` on Linux). This deployment is intended for local integration testing, not production. +Sie benötigen die JuiceFS-Binärdatei, eine Metadaten-Engine und FUSE (`fuse3` unter Linux). Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,11 +16,11 @@ flowchart LR JuiceFS -->|"data chunks"| RustFS["RustFS :9000"] ``` -JuiceFS splits every file into chunks and stores them as objects under `chunks/` in the bucket, while the metadata engine tracks names, inodes, and layout. The filesystem behaves like a local disk but holds no data locally. +JuiceFS teilt jede Datei in Chunks und speichert sie als Objekte unter `chunks/` im Bucket, während die Metadaten-Engine Namen, Inodes und das Layout führt. Das Dateisystem verhält sich wie eine lokale Platte, hält lokal aber keine Daten. -## 1. Format the volume +## 1. Das Volume formatieren -Create the bucket and format a JuiceFS volume backed by RustFS, replacing all connection placeholders. The bucket URL carries the endpoint, which selects path-style addressing: +Legen Sie den Bucket an und formatieren Sie ein JuiceFS-Volume auf RustFS. Ersetzen Sie alle Verbindungsplatzhalter. Die Bucket-URL trägt den Endpunkt und wählt damit pfadbasierte Adressierung (Path-Style): ```bash rc mb rustfs/jfs-demo @@ -39,11 +39,11 @@ Data use s3://:9000/jfs-demo/rustfs-jfs/ OK, rustfs-jfs is ready ``` -`sqlite3:///opt/juicefs/jfs.db` is the metadata engine for this test. In production, use Redis, MySQL, or PostgreSQL instead so multiple clients can mount the same volume. +`sqlite3:///opt/juicefs/jfs.db` ist die Metadaten-Engine für diesen Test. Verwenden Sie in der Produktion stattdessen Redis, MySQL oder PostgreSQL, damit mehrere Clients dasselbe Volume einhängen können. -## 2. Mount the volume +## 2. Das Volume einhängen -Mount the filesystem with the same metadata URL: +Hängen Sie das Dateisystem mit derselben Metadaten-URL ein: ```bash mkdir -p /mnt/jfs @@ -54,11 +54,11 @@ juicefs mount -d sqlite3:///opt/juicefs/jfs.db /mnt/jfs OK, rustfs-jfs is ready at /mnt/jfs ``` -The `-d` flag runs the mount in the background. The volume is now a POSIX filesystem. +Das Flag `-d` lässt den Mount im Hintergrund laufen. Das Volume ist jetzt ein POSIX-Dateisystem. -## 3. Read and write files +## 3. Dateien lesen und schreiben -Use the mount like any other directory: +Verwenden Sie den Mount wie jedes andere Verzeichnis: ```bash echo "hello rustfs jfs" > /mnt/jfs/hello.txt @@ -71,7 +71,7 @@ cat /mnt/jfs/hello.txt hello rustfs jfs ``` -Inspect the volume with `juicefs info`: +Prüfen Sie das Volume mit `juicefs info`: ```text /mnt/jfs : @@ -81,15 +81,15 @@ Inspect the volume with `juicefs info`: length: 3.00 MiB ``` -## 4. Verify chunks in RustFS +## 4. Chunks in RustFS prüfen -List the bucket prefixes: +Listen Sie die Bucket-Präfixe auf: ```bash rc ls rustfs/jfs-demo/ -r ``` -Every file was split into content-addressed chunk objects: +Jede Datei wurde in inhaltsadressierte Chunk-Objekte aufgeteilt: ```text rustfs-jfs/chunks/0/0/1_0_17 @@ -97,13 +97,13 @@ rustfs-jfs/chunks/0/0/3_0_3145728 rustfs-jfs/chunks/0/0/4_0_7 ``` -The chunk name encodes the inode, chunk index, and size — for example `3_0_3145728` is the 3 MiB file written in step 3. +Der Chunk-Name kodiert Inode, Chunk-Index und Größe. `3_0_3145728` ist zum Beispiel die 3-MiB-Datei aus Schritt 3. -![JuiceFS data chunks stored in the RustFS Console](./images/rustfs-juicefs-chunks.png) +![In der RustFS-Console gespeicherte JuiceFS-Daten-Chunks](./images/rustfs-juicefs-chunks.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -Unmount the volume, then optionally wipe the volume metadata and bucket data: +Hängen Sie das Volume aus und löschen Sie optional die Volume-Metadaten und die Bucket-Daten: ```bash juicefs umount /mnt/jfs @@ -111,22 +111,22 @@ juicefs destroy --force sqlite3:///opt/juicefs/jfs.db rustfs-jfs rc rm rustfs/jfs-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `unknown option: --daemon` -The background flag is a single dash: `juicefs mount -d`. Running without it keeps the mount in the foreground (useful for debugging). +Das Hintergrund-Flag hat einen einzelnen Bindestrich: `juicefs mount -d`. Ohne das Flag bleibt der Mount im Vordergrund (nützlich zur Fehlersuche). ### `fusermount3: mount failed: Permission denied` -Mounting requires the FUSE device. Inside a container, add `--device /dev/fuse --cap-add SYS_ADMIN` (or `--privileged`); on a host, install `fuse3` and confirm `/dev/fuse` exists. +Das Einhängen braucht das FUSE-Gerät. Fügen Sie in einem Container `--device /dev/fuse --cap-add SYS_ADMIN` hinzu (oder `--privileged`). Installieren Sie auf einem Host `fuse3` und prüfen Sie, dass `/dev/fuse` existiert. -### Mount hangs or fails to reach storage +### Der Mount hängt oder erreicht den Speicher nicht -The client must reach both the metadata engine and the bucket endpoint. Because the bucket URL embeds the endpoint, verify it from the mounting host with `curl` before formatting. +Der Client muss sowohl die Metadaten-Engine als auch den Bucket-Endpunkt erreichen. Weil die Bucket-URL den Endpunkt enthält, prüfen Sie ihn vom Mount-Host aus mit `curl`, bevor Sie formatieren. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional JuiceFS storage backends. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [JuiceFS documentation](https://juicefs.com/docs/community/quick_start_guide/) to switch the metadata engine to Redis and mount the volume from multiple clients. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere JuiceFS-Speicher-Backends einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [JuiceFS-Dokumentation](https://juicefs.com/docs/community/quick_start_guide/), um die Metadaten-Engine auf Redis umzustellen und das Volume von mehreren Clients einzuhängen. diff --git a/content/de/developer/integration/others/nextcloud.md b/content/de/developer/integration/others/nextcloud.md index f506d75ca..65a4b86ac 100644 --- a/content/de/developer/integration/others/nextcloud.md +++ b/content/de/developer/integration/others/nextcloud.md @@ -1,13 +1,13 @@ --- title: "Nextcloud" -description: "Use RustFS as S3 external storage for Nextcloud files." +description: "Nutzen Sie RustFS als externen S3-Speicher für Nextcloud-Dateien." --- -This guide connects [Nextcloud](https://github.com/nextcloud/server) — the self-hosted content collaboration platform — to **RustFS** through its External Storage app with the S3 backend. You will enable `files_external`, mount a RustFS bucket into every user's files view, and upload a file through WebDAV that lands directly in the bucket. The workflow was verified with `nextcloud:32.0.15` (SQLite, single container) against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Nextcloud](https://github.com/nextcloud/server) — die selbst gehostete Plattform für Zusammenarbeit an Inhalten — über die App External Storage mit dem S3-Backend mit **RustFS**. Sie aktivieren `files_external`, hängen einen RustFS-Bucket in die Dateiansicht jedes Benutzers ein und laden eine Datei über WebDAV hoch, die direkt im Bucket landet. Der Ablauf wurde mit `nextcloud:32.0.15` (SQLite, einzelner Container) gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker, or an existing Nextcloud instance with `occ` access. This deployment is intended for local integration testing, not production. +Sie benötigen Docker oder eine vorhandene Nextcloud-Instanz mit Zugriff auf `occ`. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR Nextcloud -->|"files_external (S3)"| RustFS["RustFS :9000"] ``` -Nextcloud proxies file operations on the mount point to the S3 backend. Objects are stored under their mount-relative paths, so the bucket mirrors the names users see. +Nextcloud leitet Dateioperationen am Mount-Punkt an das S3-Backend weiter. Objekte liegen unter ihren Pfaden relativ zum Mount, daher spiegelt der Bucket die Namen, die Benutzer sehen. -## 1. Install Nextcloud +## 1. Nextcloud installieren -Run Nextcloud with an admin account, replacing all connection placeholders. SQLite keeps the test self-contained; use MariaDB or PostgreSQL in production: +Starten Sie Nextcloud mit einem Admin-Konto und ersetzen Sie alle Verbindungsplatzhalter. SQLite hält den Test in sich geschlossen. Verwenden Sie in der Produktion MariaDB oder PostgreSQL: ```bash docker run -d --name nextcloud --network oo-rustfs_default -p 8080:80 \ @@ -28,16 +28,16 @@ docker run -d --name nextcloud --network oo-rustfs_default -p 8080:80 \ nextcloud:32.0.15 ``` -If the web UI still shows the installer after startup, finish it manually: +Wenn die Weboberfläche nach dem Start noch den Installer zeigt, schließen Sie ihn manuell ab: ```bash docker exec -u www-data nextcloud php occ maintenance:install \ --admin-user --admin-password ``` -## 2. Enable the External Storage app +## 2. Die App External Storage aktivieren -The `files_external` app ships with Nextcloud but starts disabled, and its `occ` commands only exist once the app is enabled: +Die App `files_external` gehört zu Nextcloud, startet aber deaktiviert, und ihre `occ`-Befehle existieren erst, wenn die App aktiviert ist: ```bash docker exec -u www-data nextcloud php occ app:enable files_external @@ -47,9 +47,9 @@ docker exec -u www-data nextcloud php occ app:enable files_external files_external 1.24.1 enabled ``` -## 3. Mount the RustFS bucket +## 3. Den RustFS-Bucket einhängen -Create an external storage of backend type `amazons3` with the `amazons3::accesskey` authentication backend. Replace all connection placeholders: +Legen Sie einen externen Speicher vom Backend-Typ `amazons3` mit dem Authentifizierungs-Backend `amazons3::accesskey` an. Ersetzen Sie alle Verbindungsplatzhalter: ```bash docker exec -u www-data nextcloud php occ files_external:create \ @@ -68,7 +68,7 @@ docker exec -u www-data nextcloud php occ files_external:create \ Storage created with id 1 ``` -The mount point `/rustfs` appears in the files view of the given user. `use_path_style=true` is required for a non-AWS endpoint. Check the connection before using it: +Der Mount-Punkt `/rustfs` erscheint in der Dateiansicht des angegebenen Benutzers. `use_path_style=true` wählt pfadbasierte Adressierung (Path-Style) und ist für einen Endpunkt außerhalb von AWS erforderlich. Prüfen Sie die Verbindung, bevor Sie sie verwenden: ```bash docker exec -u www-data nextcloud php occ files_external:verify 1 @@ -79,9 +79,9 @@ docker exec -u www-data nextcloud php occ files_external:verify 1 - code: 0 ``` -## 4. Upload a file and verify +## 4. Eine Datei hochladen und prüfen -Upload through the WebDAV endpoint, which writes through the external storage: +Laden Sie über den WebDAV-Endpunkt hoch, der über den externen Speicher schreibt: ```bash echo "nextcloud writes to rustfs" > /tmp/nc-demo.txt @@ -96,7 +96,7 @@ curl -u : \ 201 ``` -Read it back through the same path, then confirm the object in RustFS: +Lesen Sie sie über denselben Pfad zurück und bestätigen Sie dann das Objekt in RustFS: ```bash rc ls rustfs// -r @@ -106,40 +106,40 @@ rc ls rustfs// -r [2026-09-29 13:42:48] 27 B nc-demo.txt ``` -The object key equals the path inside the mount, so files uploaded through Nextcloud can also be read directly with any S3 client. +Der Objektschlüssel entspricht dem Pfad innerhalb des Mounts, daher lassen sich über Nextcloud hochgeladene Dateien auch direkt mit jedem S3-Client lesen. -![Nextcloud file stored in the RustFS Console](./images/rustfs-nextcloud-file.png) +![In der RustFS-Console gespeicherte Nextcloud-Datei](./images/rustfs-nextcloud-file.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -To remove the mount without touching the bucket: +Um den Mount zu entfernen, ohne den Bucket anzufassen: ```bash docker exec -u www-data nextcloud php occ files_external:delete 1 ``` -To delete the bucket contents: +Um den Bucket-Inhalt zu löschen: ```bash rc rm rustfs// --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `There are no commands defined in the "files_external" namespace` -The app is not enabled yet. Run `occ app:enable files_external` first; the `occ files_external:*` commands only register afterwards. +Die App ist noch nicht aktiviert. Führen Sie zuerst `occ app:enable files_external` aus. Die Befehle `occ files_external:*` registrieren sich erst danach. ### `Not enough arguments (missing: "authentication_backend")` -`files_external:create` takes the storage backend and the authentication backend as two separate arguments: `amazons3 amazons3::accesskey`. The backend identifiers are listed by `occ files_external:backends`. +`files_external:create` nimmt das Speicher-Backend und das Authentifizierungs-Backend als zwei getrennte Argumente: `amazons3 amazons3::accesskey`. Die Backend-Bezeichner listet `occ files_external:backends` auf. -### Mount shows but is empty, or uploads fail +### Der Mount erscheint, ist aber leer, oder Uploads schlagen fehl -Confirm `hostname` is reachable from the Nextcloud container (use the container network name, not `localhost`), `use_path_style` is `true`, and the bucket exists. `occ files_external:verify ` reports the exact connection error. +Prüfen Sie, dass `hostname` vom Nextcloud-Container aus erreichbar ist (verwenden Sie den Namen im Container-Netzwerk, nicht `localhost`), dass `use_path_style` `true` ist und dass der Bucket existiert. `occ files_external:verify ` meldet den genauen Verbindungsfehler. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional external storage backends. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Nextcloud external storage documentation](https://docs.nextcloud.com/server/latest/admin_manual/configuration_files/external_storage_configuration_gui.html) to share the mount with groups and enable versioning. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Backends für externen Speicher einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Nextcloud-Dokumentation zum externen Speicher](https://docs.nextcloud.com/server/latest/admin_manual/configuration_files/external_storage_configuration_gui.html), um den Mount mit Gruppen zu teilen und Versionierung zu aktivieren. diff --git a/content/de/developer/integration/others/rclone.md b/content/de/developer/integration/others/rclone.md index 34f9fe4aa..71074924e 100644 --- a/content/de/developer/integration/others/rclone.md +++ b/content/de/developer/integration/others/rclone.md @@ -1,13 +1,13 @@ --- title: "rclone" -description: "Sync, mount, and serve RustFS buckets with rclone over its S3-compatible API." +description: "Synchronisieren Sie RustFS-Buckets mit rclone, hängen Sie sie ein und stellen Sie sie über die S3-kompatible API bereit." --- -This guide connects [rclone](https://github.com/rclone/rclone) — the command-line tool for syncing files to and from cloud storage — to **RustFS** through its S3 backend. You will configure an S3 remote for RustFS, copy and sync files, read objects back, publish a bucket over HTTP with `rclone serve`, and mount the bucket as a local filesystem with `rclone mount`. The workflow was verified with `rclone v1.75.1` against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [rclone](https://github.com/rclone/rclone) — das Kommandozeilenwerkzeug zum Synchronisieren von Dateien mit Cloud-Speicher — über sein S3-Backend mit **RustFS**. Sie konfigurieren ein S3-Remote für RustFS, kopieren und synchronisieren Dateien, lesen Objekte zurück, veröffentlichen einen Bucket über HTTP mit `rclone serve` und hängen den Bucket mit `rclone mount` als lokales Dateisystem ein. Der Ablauf wurde mit `rclone v1.75.1` gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker, or a local rclone binary. This deployment is intended for local integration testing, not production. +Sie benötigen Docker oder eine lokale rclone-Binärdatei. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -16,11 +16,11 @@ flowchart LR RustFS -->|"mount / serve"| Client["FUSE mount / HTTP clients"] ``` -One remote definition drives every rclone command: data transfer, mounting, and serving all use the same S3 connection. +Eine Remote-Definition steuert jeden rclone-Befehl: Datentransfer, Mount und Bereitstellung verwenden dieselbe S3-Verbindung. -## 1. Configure the remote +## 1. Das Remote konfigurieren -Create an rclone config file with an S3 remote for RustFS, replacing all connection placeholders. The `Other` provider disables AWS-specific behavior, and path-style addressing is used automatically for custom endpoints: +Legen Sie eine rclone-Konfigurationsdatei mit einem S3-Remote für RustFS an und ersetzen Sie alle Verbindungsplatzhalter. Der Provider `Other` schaltet AWS-spezifisches Verhalten ab, und für eigene Endpunkte wird pfadbasierte Adressierung (Path-Style) automatisch verwendet: ```ini title="rclone.conf" [rustfs] @@ -32,16 +32,16 @@ endpoint = http://:9000 region = us-east-1 ``` -## 2. Copy and read objects +## 2. Objekte kopieren und lesen -Create the bucket and upload a directory with `rclone copy`: +Legen Sie den Bucket an und laden Sie ein Verzeichnis mit `rclone copy` hoch: ```bash rc mb rustfs/rclone-demo rclone copy /data rustfs:rclone-demo/seed ``` -List and read back: +Listen Sie auf und lesen Sie zurück: ```bash rclone ls rustfs:rclone-demo/seed @@ -54,11 +54,11 @@ rclone cat rustfs:rclone-demo/seed/hello.txt hello from rclone ``` -`rclone lsd rustfs:` lists every bucket on the endpoint. +`rclone lsd rustfs:` listet jeden Bucket am Endpunkt auf. -## 3. Sync a directory +## 3. Ein Verzeichnis synchronisieren -`rclone sync` makes the destination identical to the source, including deletions. Remove a local file and sync: +`rclone sync` macht das Ziel identisch mit der Quelle, einschließlich Löschungen. Entfernen Sie eine lokale Datei und synchronisieren Sie: ```bash rm /data/hello.txt @@ -70,17 +70,17 @@ rclone lsf rustfs:rclone-demo/seed blob.bin ``` -`hello.txt` disappears from the bucket. Add `--dry-run` first to preview the changes without touching the bucket. +`hello.txt` verschwindet aus dem Bucket. Fügen Sie zuerst `--dry-run` hinzu, um die Änderungen vorzuschauen, ohne den Bucket zu verändern. -## 4. Serve a bucket over HTTP +## 4. Einen Bucket über HTTP bereitstellen -Publish the bucket contents as an HTTP file server: +Veröffentlichen Sie den Bucket-Inhalt als HTTP-Dateiserver: ```bash rclone serve http --addr 0.0.0.0:8080 rustfs:rclone-demo/seed ``` -Any HTTP client can now download objects: +Jeder HTTP-Client kann die Objekte jetzt herunterladen: ```bash curl -s http://localhost:8080/blob.bin -o /dev/null -w "%{http_code} %{size_download} bytes\n" @@ -90,11 +90,11 @@ curl -s http://localhost:8080/blob.bin -o /dev/null -w "%{http_code} %{size_down 200 3145728 bytes ``` -`rclone serve` also supports WebDAV, SFTP, and S3 endpoints over the same remote. +`rclone serve` unterstützt außerdem WebDAV-, SFTP- und S3-Endpunkte über dasselbe Remote. -## 5. Mount the bucket as a filesystem +## 5. Den Bucket als Dateisystem einhängen -With FUSE available, mount the bucket locally and use it like a directory: +Wenn FUSE verfügbar ist, hängen Sie den Bucket lokal ein und verwenden Sie ihn wie ein Verzeichnis: ```bash rclone mount rustfs:rclone-demo /mnt/rclone --daemon @@ -103,7 +103,7 @@ echo test > /mnt/rclone/write-test.txt cat /mnt/rclone/write-test.txt ``` -Files written through the mount appear in RustFS as regular objects: +Dateien, die über den Mount geschrieben werden, erscheinen in RustFS als gewöhnliche Objekte: ```bash rc ls rustfs/rclone-demo/ -r @@ -113,32 +113,32 @@ rc ls rustfs/rclone-demo/ -r [2026-09-29 11:12:41] 5 B write-test.txt ``` -Unmount with `fusermount -u /mnt/rclone` when finished. +Hängen Sie mit `fusermount -u /mnt/rclone` aus, wenn Sie fertig sind. -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen -rclone holds no server-side state. To delete the demo data: +rclone hält keinen serverseitigen Zustand. So löschen Sie die Demo-Daten: ```bash rclone purge rustfs:rclone-demo ``` -## Troubleshooting +## Fehlerbehebung -### `Access Denied` or empty listings +### `Access Denied` oder leere Auflistungen -Confirm `endpoint` includes the scheme and that the key pair matches a RustFS access key. The `region` value is required by the S3 signer even though RustFS ignores it; keep `us-east-1`. +Prüfen Sie, dass `endpoint` das Schema enthält und dass das Schlüsselpaar zu einem RustFS-Zugriffsschlüssel passt. Der Wert `region` ist für den S3-Signer erforderlich, auch wenn RustFS ihn ignoriert. Belassen Sie `us-east-1`. -### Mount fails with `fusermount3: mount failed: Permission denied` +### Der Mount scheitert mit `fusermount3: mount failed: Permission denied` -Mounting needs the FUSE device and elevated privileges. Inside a container, run with `--device /dev/fuse --cap-add SYS_ADMIN` — and use `--privileged` if the mount helper still fails. On a host, verify that `fuse3` is installed and `/dev/fuse` exists. +Das Einhängen braucht das FUSE-Gerät und erhöhte Rechte. Starten Sie in einem Container mit `--device /dev/fuse --cap-add SYS_ADMIN` und verwenden Sie `--privileged`, wenn der Mount-Helfer weiterhin scheitert. Prüfen Sie auf einem Host, dass `fuse3` installiert ist und `/dev/fuse` existiert. -### Sync deleted nothing on the destination +### Die Synchronisierung hat am Ziel nichts gelöscht -`rclone copy` never deletes. Only `rclone sync` (or `rclone delete`) removes destination objects, and `--dry-run` is the safe way to preview either. +`rclone copy` löscht nie. Nur `rclone sync` (oder `rclone delete`) entfernt Zielobjekte, und `--dry-run` ist der sichere Weg, beides vorzuschauen. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional rclone backends. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [rclone S3 documentation](https://rclone.org/s3/) for flags such as `--transfers`, bandwidth limits, and crypt overlays. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere rclone-Backends einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [rclone-S3-Dokumentation](https://rclone.org/s3/) für Flags wie `--transfers`, Bandbreitengrenzen und Crypt-Overlays. diff --git a/content/de/developer/integration/others/tusd.md b/content/de/developer/integration/others/tusd.md index 99f3c5884..6609bab20 100644 --- a/content/de/developer/integration/others/tusd.md +++ b/content/de/developer/integration/others/tusd.md @@ -1,13 +1,13 @@ --- title: "tusd" -description: "Receive resumable uploads into RustFS with the tusd server's S3 backend." +description: "Nehmen Sie fortsetzbare Uploads mit dem S3-Backend des tusd-Servers in RustFS entgegen." --- -This guide connects [tusd](https://github.com/tus/tusd) — the official reference implementation of the tus resumable-upload protocol — to **RustFS** as its S3 storage backend. You will run tusd against a RustFS bucket, create an upload with the tus protocol, send the file in two chunks with an interruption in between, resume from the reported offset, and verify the assembled object in the bucket. The workflow was verified with `tusproject/tusd:v2.10.1` against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [tusd](https://github.com/tus/tusd) — die offizielle Referenzimplementierung des tus-Protokolls für fortsetzbare Uploads — mit **RustFS** als S3-Speicher-Backend. Sie betreiben tusd gegen einen RustFS-Bucket, legen einen Upload mit dem tus-Protokoll an, senden die Datei in zwei Teilen mit einer Unterbrechung dazwischen, setzen am gemeldeten Offset fort und prüfen das zusammengesetzte Objekt im Bucket. Der Ablauf wurde mit `tusproject/tusd:v2.10.1` gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker, or a local tusd binary. This deployment is intended for local integration testing, not production. +Sie benötigen Docker oder eine lokale tusd-Binärdatei. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR tusd -->|"multipart upload"| RustFS["RustFS :9000"] ``` -tusd stores each in-progress upload as S3 multipart parts in the bucket. A client that loses its connection asks the server for the last committed offset with `HEAD` and continues from there — the data already received is never sent twice. +tusd speichert jeden laufenden Upload als Teile eines mehrteiligen Uploads im Bucket. Ein Client, der die Verbindung verliert, fragt den Server mit `HEAD` nach dem zuletzt committeten Offset und setzt dort fort. Bereits empfangene Daten werden nie ein zweites Mal gesendet. -## 1. Run tusd +## 1. tusd starten -Create the bucket and start tusd with the S3 backend, replacing all connection placeholders. The AWS region must be set even though RustFS ignores it: +Legen Sie den Bucket an und starten Sie tusd mit dem S3-Backend. Ersetzen Sie alle Verbindungsplatzhalter. Die AWS-Region muss gesetzt sein, auch wenn RustFS sie ignoriert: ```bash rc mb rustfs/tus-uploads @@ -33,7 +33,7 @@ docker run -d --name tusd --network oo-rustfs_default -p 8080:8080 \ -s3-endpoint http://:9000 ``` -Check that the server is healthy: +Prüfen Sie, dass der Server gesund ist: ```bash curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8080/health @@ -43,9 +43,9 @@ curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8080/health 200 ``` -## 2. Create the upload +## 2. Den Upload anlegen -Create a 6 MiB upload and read the `Location` header: +Legen Sie einen Upload von 6 MiB an und lesen Sie den Header `Location`: ```bash curl -s -D - -o /dev/null -X POST http://localhost:8080/files/ \ @@ -57,11 +57,11 @@ curl -s -D - -o /dev/null -X POST http://localhost:8080/files/ \ Location: http://localhost:8080/files/b7338250daa9...+NGVmNDRhZjEt... ``` -The upload URL contains the file ID and a message-authentication tag. Strip the scheme and host before re-sending it (the server echoes whatever `Host` it received, which may not be reachable from your next client). +Die Upload-URL enthält die Datei-ID und ein Nachrichtenauthentifizierungs-Tag. Entfernen Sie Schema und Host, bevor Sie sie erneut senden. Der Server gibt den `Host` zurück, den er empfangen hat, und der ist vom nächsten Client aus möglicherweise nicht erreichbar. -## 3. Upload in chunks with an interruption +## 3. In Teilen mit einer Unterbrechung hochladen -Send the first 2.5 MB, then stop — this is the point where a mobile client would lose its connection: +Senden Sie die ersten 2,5 MB und stoppen Sie dann. An dieser Stelle würde ein mobiler Client die Verbindung verlieren: ```bash head -c 2500000 demo.bin > part1.bin @@ -76,7 +76,7 @@ curl -s -o /dev/null -w "%{http_code}\n" -X PATCH "http://localhost:8080${LOC}" 204 ``` -Ask the server how much it actually has — this is the resumable-upload core: +Fragen Sie den Server, wie viel er tatsächlich hat. Das ist der Kern des fortsetzbaren Uploads: ```bash curl -s -X HEAD "http://localhost:8080${LOC}" \ @@ -87,9 +87,9 @@ curl -s -X HEAD "http://localhost:8080${LOC}" \ Upload-Offset: 2500000 ``` -## 4. Resume and finish +## 4. Fortsetzen und abschließen -Continue from offset 2500000 with the remaining bytes: +Setzen Sie ab Offset 2500000 mit den restlichen Bytes fort: ```bash tail -c 3791456 demo.bin > part2.bin @@ -104,7 +104,7 @@ curl -s -o /dev/null -w "%{http_code}\n" -X PATCH "http://localhost:8080${LOC}" 204 ``` -Download the finished upload through tusd and compare checksums with the source: +Laden Sie den fertigen Upload über tusd herunter und vergleichen Sie die Prüfsummen mit der Quelle: ```bash curl -s -o download.bin "http://localhost:8080${LOC}" @@ -116,55 +116,55 @@ d9016032ced6c7515b67a0c556e006c4b25a5858 demo.bin d9016032ced6c7515b67a0c556e006c4b25a5858 download.bin ``` -## 5. Verify objects in RustFS +## 5. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/tus-uploads/ -r ``` -The bucket holds the assembled object plus one `.info` metadata file per upload — both live and finished: +Der Bucket enthält das zusammengesetzte Objekt plus eine Metadatendatei `.info` je Upload, sowohl laufende als auch abgeschlossene: ```text b7338250daa9a1a79c1343502b57b28f 6 MiB b7338250daa9a1a79c1343502b57b28f.info 378 B ``` -The object key is the upload ID, and the object body is the uploaded file byte-for-byte — so any S3 client can read completed uploads directly from the bucket. +Der Objektschlüssel ist die Upload-ID, und der Objektkörper ist die hochgeladene Datei Byte für Byte. Jeder S3-Client kann abgeschlossene Uploads daher direkt aus dem Bucket lesen. -![tus uploads stored in the RustFS Console](./images/rustfs-tus-uploads.png) +![In der RustFS-Console gespeicherte tus-Uploads](./images/rustfs-tus-uploads.png) -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen -To tear down the server while keeping the bucket objects: +Um den Server abzubauen und die Bucket-Objekte zu behalten: ```bash docker rm -f tusd ``` -To delete the stored uploads: +Um die gespeicherten Uploads zu löschen: ```bash rc rm rustfs/tus-uploads/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `CreateMultipartUpload ... A region must be set when sending requests to S3` -tusd builds its S3 client from the AWS environment, and the region is mandatory for endpoint resolution. Export `AWS_REGION=us-east-1` next to the credentials, as in step 1. +tusd baut seinen S3-Client aus der AWS-Umgebung, und die Region ist für die Endpunktauflösung zwingend. Exportieren Sie `AWS_REGION=us-east-1` neben den Zugangsdaten, wie in Schritt 1. -### `PATCH` returns `404` or connects to the wrong host +### `PATCH` antwortet mit `404` oder verbindet sich mit dem falschen Host -The `Location` URL echoes the `Host` header of the creation request. When your client and the server use different hostnames (container name versus published port), strip the scheme and host from the URL and send the path to the address the client can reach. +Die URL `Location` gibt den Header `Host` der Erstellungsanfrage zurück. Wenn Client und Server unterschiedliche Hostnamen verwenden (Container-Name gegenüber veröffentlichtem Port), entfernen Sie Schema und Host aus der URL und senden Sie den Pfad an die Adresse, die der Client erreichen kann. -### Upload disappears after server restart +### Der Upload verschwindet nach einem Server-Neustart -The S3 backend keeps `.info` files in the bucket, so uploads survive restarts. If you run tusd against an empty bucket that another process prunes, the metadata is lost — protect the `tus-uploads` prefix from cleanup jobs. +Das S3-Backend behält `.info`-Dateien im Bucket, daher überstehen Uploads Neustarts. Wenn Sie tusd gegen einen leeren Bucket betreiben, den ein anderer Prozess aufräumt, gehen die Metadaten verloren. Schützen Sie das Präfix `tus-uploads` vor Aufräumjobs. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional tusd backends. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [tus protocol documentation](https://tus.io/protocols/resumable-upload) for creation-with-upload, termination, and checksum extensions that tusd supports on top of the core protocol. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere tusd-Backends einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Dokumentation zum tus-Protokoll](https://tus.io/protocols/resumable-upload) für Creation-with-Upload, Termination und Prüfsummen-Erweiterungen, die tusd zusätzlich zum Kernprotokoll unterstützt. diff --git a/content/de/developer/integration/registry/docker-registry.md b/content/de/developer/integration/registry/docker-registry.md index ae84704a4..afeb5b122 100644 --- a/content/de/developer/integration/registry/docker-registry.md +++ b/content/de/developer/integration/registry/docker-registry.md @@ -1,13 +1,13 @@ --- title: "Docker Registry" -description: "Store container images from Docker Registry in RustFS." +description: "Speichern Sie Container-Images aus der Docker Registry in RustFS." --- -This guide connects the open-source [Docker Registry](https://github.com/distribution/distribution) (distribution) to **RustFS** as its S3 storage backend. You will run a registry that stores all layers and manifests in a RustFS bucket, then push and pull an image. The workflow was verified with `registry:2` against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie die quelloffene [Docker Registry](https://github.com/distribution/distribution) (distribution) mit **RustFS** als S3-Speicher-Backend. Sie betreiben eine Registry, die alle Layer und Manifeste in einem RustFS-Bucket speichert, und pushen und pullen anschließend ein Image. Der Ablauf wurde mit `registry:2` gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker on the registry host. +Sie benötigen Docker auf dem Registry-Host. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR Reg -->|"blobs + manifests"| RustFS["RustFS :9000"] ``` -The registry stores every blob (layers and configs) and manifest as objects under `docker/registry/v2/` in the bucket. The container itself is stateless, so registry nodes can be scaled horizontally against the same bucket. +Die Registry speichert jeden Blob (Layer und Konfigurationen) und jedes Manifest als Objekte unter `docker/registry/v2/` im Bucket. Der Container selbst ist zustandslos, daher lassen sich Registry-Knoten horizontal mit demselben Bucket skalieren. -## 1. Run the registry +## 1. Registry ausführen -Configure the S3 driver entirely through environment variables. `REGISTRY_STORAGE_S3_REGIONENDPOINT` points the AWS SDK at RustFS: +Konfigurieren Sie den S3-Treiber ausschließlich über Umgebungsvariablen. `REGISTRY_STORAGE_S3_REGIONENDPOINT` richtet das AWS SDK auf RustFS aus: ```bash docker run -d --name registry --network oo-rustfs_default -p 5000:5000 \ @@ -32,19 +32,20 @@ docker run -d --name registry --network oo-rustfs_default -p 5000:5000 \ registry:2 ``` -Check that the v2 API is up: +Prüfen Sie, dass die v2-API bereit ist: ```bash curl -s -o /dev/null -w "%{http_code}\n" http://localhost:5000/v2/ ``` + ```text 200 ``` -## 2. Push an image +## 2. Image pushen -Tag any local image for the registry and push it: +Taggen Sie ein lokales Image für die Registry und pushen Sie es: ```bash docker pull alpine:3.20 @@ -52,64 +53,67 @@ docker tag alpine:3.20 localhost:5000/rustfs-demo/alpine:3.20 docker push localhost:5000/rustfs-demo/alpine:3.20 ``` + ```text 3.20: digest: sha256:c64c687cbea9300178b30c95835354e34c4e4febc4badfe27102879de0483b5e ``` -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen ```bash rc ls rustfs/registry-demo/docker/registry/v2/repositories/rustfs-demo/alpine/ -r | head -4 ``` + ```text _repositories/rustfs-demo/alpine/_layers/sha256/25f1d6b1.../link _repositories/rustfs-demo/alpine/_manifests/revisions/sha256/c64c687c.../link _repositories/rustfs-demo/alpine/_manifests/tags/3.20/current/link ``` -Every `_layers` link points at a blob object stored in the same bucket — the image data itself lives in RustFS, not on the registry host. +Jeder `_layers`-Link zeigt auf ein Blob-Objekt im selben Bucket. Die Image-Daten selbst liegen in RustFS, nicht auf dem Registry-Host. -![Registry layers stored in the RustFS Console](./images/rustfs-registry-layers.png) +![In der RustFS Console gespeicherte Registry-Layer](./images/rustfs-registry-layers.png) -## 4. Pull the image back +## 4. Image zurück pullen -Remove the local copy and pull from the registry — the layers come back from RustFS: +Entfernen Sie die lokale Kopie und pullen Sie von der Registry. Die Layer kommen aus RustFS zurück: ```bash docker rmi localhost:5000/rustfs-demo/alpine:3.20 docker pull localhost:5000/rustfs-demo/alpine:3.20 ``` + ```text 3.20: Pulling from rustfs-demo/alpine Digest: sha256:c64c687cbea9300178b30c95835354e34c4e4febc4badfe27102879de0483b5e Status: Downloaded newer image for localhost:5000/rustfs-demo/alpine:3.20 ``` -## 5. Stop or reset +## 5. Anhalten oder zurücksetzen ```bash docker rm -f registry rc rm rustfs/registry-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### Push fails with `unknown` or empty digest +### Der Push schlägt mit `unknown` oder einem leeren Digest fehl -Confirm `REGISTRY_STORAGE_S3_REGIONENDPOINT` is set — without it the registry sends requests to real AWS. Also check the bucket exists. +Stellen Sie sicher, dass `REGISTRY_STORAGE_S3_REGIONENDPOINT` gesetzt ist. Ohne diese Variable sendet die Registry Anfragen an das echte AWS. Prüfen Sie außerdem, dass der Bucket existiert. -### `InvalidAccessKeyId` at push time +### `InvalidAccessKeyId` beim Push -The access key and secret key must be passed with `REGISTRY_STORAGE_S3_ACCESSKEY` / `SECRETKEY`; the registry does not read the AWS credential environment chain in this driver. +Zugriffsschlüssel und geheimer Zugriffsschlüssel müssen über `REGISTRY_STORAGE_S3_ACCESSKEY` und `SECRETKEY` übergeben werden. Die Registry liest in diesem Treiber nicht die AWS-Kette der Umgebungs-Zugangsdaten. -### Pull returns `manifest unknown` after the registry restarted +### Der Pull meldet `manifest unknown`, nachdem die Registry neu gestartet wurde -Manifests and blobs live in the bucket, so a restart cannot lose them — check that both registry instances point at the same `REGISTRY_STORAGE_S3_BUCKET` and `REGIONENDPOINT`. +Manifeste und Blobs liegen im Bucket, ein Neustart kann sie also nicht verlieren. Prüfen Sie, dass beide Registry-Instanzen auf denselben `REGISTRY_STORAGE_S3_BUCKET` und denselben `REGIONENDPOINT` zeigen. -## Next steps +## Nächste Schritte -- Compare with the [Harbor](/developer/integration/registry/harbor) guide when you need a UI, RBAC, or replication on top of the same bucket. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [distribution documentation](https://distribution.github.io/distribution/) for storage driver tuning and proxy-caching setups. +- Vergleichen Sie die Anleitung mit [Harbor](/de/developer/integration/registry/harbor), wenn Sie eine Oberfläche, RBAC oder Replikation auf demselben Bucket benötigen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [distribution-Dokumentation](https://distribution.github.io/distribution/) für die Abstimmung des Storage-Treibers und für Proxy-Caching-Setups. diff --git a/content/de/developer/integration/registry/harbor.md b/content/de/developer/integration/registry/harbor.md index 2615b9df6..af48d6012 100644 --- a/content/de/developer/integration/registry/harbor.md +++ b/content/de/developer/integration/registry/harbor.md @@ -1,9 +1,9 @@ --- title: "Harbor" -description: "Speichern Sie mit Harbor gepushte Container-Images über den S3-Storage-Treiber der Registry in RustFS; die Anleitung verwendet Docker Compose." +description: "Speichern Sie nach Harbor gepushte Container-Images über den S3-Storage-Treiber der Registry in RustFS, bereitgestellt mit Docker Compose." --- -Diese Anleitung verbindet [Harbor](https://github.com/goharbor/harbor) — die bei der CNCF graduierte Cloud-native Registry (CNCF-graduated) — mit **RustFS**. Harbor persistiert Image-Layer, Manifeste und andere OCI-Artefakte über seine eingebettete Registry-Komponente, die den S3-Storage-Treiber des [distribution](https://distribution.github.io/distribution/)-Projekts implementiert. Sie betreiben diese Registry-Komponente mit Docker Compose und RustFS als Speicher, pushen ein Image, pullen es zurück und prüfen die Objekte in RustFS. Dasselbe Speicher-Setup gilt für eine vollständige Harbor-Bereitstellung. Der Ablauf wurde mit `goharbor/registry-photon:v2.12.2` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. +Diese Anleitung verbindet [Harbor](https://github.com/goharbor/harbor) — die bei der CNCF graduierte, cloud-native Registry — mit **RustFS**. Harbor persistiert Image-Layer, Manifeste und andere OCI-Artefakte über seine eingebettete Registry-Komponente, die den S3-Storage-Treiber des [distribution](https://distribution.github.io/distribution/)-Projekts implementiert. Sie betreiben diese Registry-Komponente mit Docker Compose und RustFS als Speicher, pushen ein Image, pullen es zurück und prüfen die Objekte in RustFS. Dasselbe Speicher-Setup gilt für eine vollständige Harbor-Bereitstellung. Der Ablauf wurde mit `goharbor/registry-photon:v2.12.2` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. Sie benötigen Docker mit dem Compose-Plugin. Dieses Setup ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. @@ -203,9 +203,9 @@ docker compose run --rm --entrypoint /bin/sh create-bucket -c \ [2026-09-20 12:11:25] 71 B docker/registry/v2/repositories/demo/app/_manifests/tags/v1/index/sha256/1cfa4e2b09e127b9c4ed43578d3f3c18e7d44ea47b9ea98475c0cbe9086525f8/link ``` -Die Blob-Payloads selbst liegen unterhalb von `docker/registry/v2/blobs/`. Sie können das Präfix auch in der RustFS-Konsole unter `http://localhost:9001/rustfs/console/` anzeigen: +Die Blob-Payloads selbst liegen unterhalb von `docker/registry/v2/blobs/`. Sie können das Präfix auch in der RustFS Console unter `http://localhost:9001/rustfs/console/` anzeigen: -![Die Repository-Metadaten des gepushten Images in der RustFS-Konsole](./images/rustfs-harbor-objects.png) +![Die Repository-Metadaten des gepushten Images in der RustFS Console](./images/rustfs-harbor-objects.png) ## 6. RustFS in einer vollständigen Harbor-Bereitstellung verwenden @@ -274,6 +274,6 @@ Der Treiber schreibt unterhalb von `docker/registry/v2/` im Bucket. Listen Sie d ## Nächste Schritte -- Lesen Sie die [S3-Kompatibilitätshinweise](/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere S3-Operationen verwenden. - Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). - Folgen Sie der [Harbor-Dokumentation](https://goharbor.io/docs/), um eine vollständige Harbor-Bereitstellung mit Replikation, Vulnerability-Scanning und RBAC zu konfigurieren. diff --git a/content/de/developer/integration/reverse-proxy/caddy.md b/content/de/developer/integration/reverse-proxy/caddy.md index a49b24dae..3d1c2e03d 100644 --- a/content/de/developer/integration/reverse-proxy/caddy.md +++ b/content/de/developer/integration/reverse-proxy/caddy.md @@ -1,35 +1,35 @@ --- title: "Caddy" -description: "Deploy RustFS behind Caddy with automatic HTTPS for separate S3 API and Console hostnames." +description: "Stellen Sie RustFS hinter Caddy mit automatischem HTTPS für getrennte Hostnamen der S3-API und der Console bereit." --- -Use **Caddy** to obtain and renew TLS certificates automatically and route separate hostnames to the RustFS S3 API and Console. This deployment runs Caddy and a single-node RustFS instance with Docker Compose. You need Docker Engine, Docker Compose, a public server, and two DNS records that resolve to that server. +Verwenden Sie **Caddy**, um TLS-Zertifikate automatisch zu beziehen und zu erneuern und getrennte Hostnamen zur RustFS-S3-API und zur Console (Weboberfläche) zu leiten. In dieser Bereitstellung betreiben Sie Caddy und eine RustFS-Instanz mit einem Knoten unter Docker Compose. Sie benötigen Docker Engine, Docker Compose, einen öffentlichen Server und zwei DNS-Einträge, die auf diesen Server zeigen. -This guide uses these example hostnames: +Diese Anleitung verwendet diese Beispiel-Hostnamen: -- `s3.example.com` for the S3 API -- `console.example.com` for the Console +- `s3.example.com` für die S3-API +- `console.example.com` für die Console -Replace them with your public hostnames. Caddy's default ACME challenges require inbound access to ports `80` and `443`. +Ersetzen Sie sie durch Ihre öffentlichen Hostnamen. Die Standard-ACME-Challenges von Caddy verlangen eingehenden Zugriff auf die Ports `80` und `443`. -:::warning[Serve S3 from the root path] +:::warning[S3 vom Wurzelpfad bereitstellen] -Do not publish the S3 API under a path such as `/s3/`. AWS Signature Version 4 includes the request path and host, so rewriting either value can invalidate signed requests. +Veröffentlichen Sie die S3-API nicht unter einem Pfad wie `/s3/`. AWS Signature Version 4 enthält den Anfragepfad und den Host, daher kann das Umschreiben eines der beiden Werte signierte Anfragen ungültig machen. ::: -## 1. Create the deployment directory +## 1. Das Bereitstellungsverzeichnis anlegen -Create a directory for the deployment: +Legen Sie ein Verzeichnis für die Bereitstellung an: ```bash mkdir rustfs-caddy cd rustfs-caddy ``` -## 2. Set deployment variables +## 2. Bereitstellungsvariablen setzen -Create an environment file and replace each value: +Legen Sie eine Umgebungsdatei an und ersetzen Sie jeden Wert: ```ini title=".env" S3_HOSTNAME=s3.example.com @@ -39,11 +39,11 @@ RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Use an email address that receives certificate notices. Do not commit `.env` to source control. +Verwenden Sie eine E-Mail-Adresse, die Zertifikatshinweise empfängt. Nehmen Sie `.env` nicht in die Versionsverwaltung auf. -## 3. Configure Caddy +## 3. Caddy konfigurieren -Create a Caddyfile with one site block for each RustFS endpoint: +Legen Sie ein Caddyfile mit einem Site-Block je RustFS-Endpunkt an: ```text title="Caddyfile" { @@ -73,11 +73,11 @@ Create a Caddyfile with one site block for each RustFS endpoint: } ``` -Caddy preserves the incoming `Host` header, HTTP method, and request URI by default. It also forwards client information through `X-Forwarded-*` headers and handles Console WebSocket upgrades without additional header rules. +Caddy behält den eingehenden Header `Host`, die HTTP-Methode und die Anfrage-URI standardmäßig bei. Es leitet außerdem Client-Informationen über Header `X-Forwarded-*` weiter und verarbeitet Console-WebSocket-Upgrades ohne zusätzliche Header-Regeln. -## 4. Create the Compose file +## 4. Die Compose-Datei anlegen -Create the Caddy and RustFS services: +Legen Sie die Dienste Caddy und RustFS an: ```yaml title="compose.yaml" services: @@ -136,24 +136,24 @@ networks: rustfs: ``` -The persistent `caddy-data` volume stores certificates, private keys, and ACME account state. Back up this volume and do not share its contents. Only Caddy publishes host ports; RustFS remains reachable inside the Compose network. +Das persistente Volume `caddy-data` speichert Zertifikate, private Schlüssel und den Zustand des ACME-Kontos. Sichern Sie dieses Volume und teilen Sie seinen Inhalt nicht. Nur Caddy veröffentlicht Host-Ports. RustFS bleibt innerhalb des Compose-Netzwerks erreichbar. -## 5. Validate and start the deployment +## 5. Die Bereitstellung prüfen und starten -Render the Compose configuration and start RustFS: +Rendern Sie die Compose-Konfiguration und starten Sie RustFS: ```bash docker compose config docker compose up -d rustfs ``` -Validate the Caddyfile with the same image used by the deployment: +Prüfen Sie das Caddyfile mit demselben Image, das die Bereitstellung verwendet: ```bash docker compose run --rm --no-deps caddy caddy validate --config /etc/caddy/Caddyfile ``` -Start Caddy and check both services: +Starten Sie Caddy und prüfen Sie beide Dienste: ```bash docker compose up -d caddy @@ -161,22 +161,22 @@ docker compose ps docker compose logs --follow caddy ``` -Caddy obtains certificates in the background and redirects HTTP requests to HTTPS. If issuance fails, confirm that both DNS records resolve to this host, ports `80` and `443` are reachable, and the `caddy-data` volume is writable. +Caddy bezieht Zertifikate im Hintergrund und leitet HTTP-Anfragen auf HTTPS um. Wenn die Ausstellung scheitert, prüfen Sie, dass beide DNS-Einträge auf diesen Host zeigen, dass die Ports `80` und `443` erreichbar sind und dass das Volume `caddy-data` beschreibbar ist. -## 6. Verify both endpoints +## 6. Beide Endpunkte prüfen -Verify the API and Console through their public HTTPS hostnames: +Prüfen Sie die API und die Console über ihre öffentlichen HTTPS-Hostnamen: ```bash curl --fail https://s3.example.com/health/ready curl --fail https://console.example.com/rustfs/console/health ``` -Configure S3 clients with `https://s3.example.com` as the endpoint and enable path-style addressing. Open `https://console.example.com/rustfs/console/` to sign in to the Console. +Konfigurieren Sie S3-Clients mit `https://s3.example.com` als Endpunkt und aktivieren Sie pfadbasierte Adressierung (Path-Style). Öffnen Sie `https://console.example.com/rustfs/console/`, um sich an der Console anzumelden. -## Multi-node upstreams +## Upstreams mit mehreren Knoten -For a distributed RustFS deployment, list every node in the corresponding site block: +Listen Sie für eine verteilte RustFS-Bereitstellung jeden Knoten im zugehörigen Site-Block auf: ```text title="Caddyfile" {$S3_HOSTNAME} { @@ -200,10 +200,10 @@ For a distributed RustFS deployment, list every node in the corresponding site b } ``` -Replace `` with a random secret shared by all Caddy instances. Console affinity keeps an in-progress OpenID Connect login on the RustFS node that created its `state`. Keep port `9000` open directly between RustFS nodes because internal node RPC uses the same listener. +Ersetzen Sie `` durch ein zufälliges Geheimnis, das alle Caddy-Instanzen teilen. Die Console-Affinität hält eine laufende OpenID-Connect-Anmeldung auf dem RustFS-Knoten, der ihren `state` erzeugt hat. Halten Sie Port `9000` direkt zwischen den RustFS-Knoten offen, weil der interne Knoten-RPC denselben Listener verwendet. -## Next steps +## Nächste Schritte -- [Configure an S3 client](/developer/examples/aws-cli) -- [Enable virtual-hosted-style bucket URLs](/integration/virtual) -- [Review health and readiness endpoints](/operations/status-check) \ No newline at end of file +- [Einen S3-Client konfigurieren](/de/developer/examples/aws-cli) +- [Bucket-URLs mit Adressierung im Virtual-Hosted-Stil aktivieren](/de/integration/virtual) +- [Endpunkte für Integritätsprüfung und Bereitschaft prüfen](/de/operations/status-check) diff --git a/content/de/developer/integration/reverse-proxy/envoy.md b/content/de/developer/integration/reverse-proxy/envoy.md index dc635a48d..f154a2b9f 100644 --- a/content/de/developer/integration/reverse-proxy/envoy.md +++ b/content/de/developer/integration/reverse-proxy/envoy.md @@ -1,33 +1,33 @@ --- title: "Envoy" -description: "Deploy RustFS behind Envoy with TLS-terminated routes for the S3 API and Console." +description: "Stellen Sie RustFS hinter Envoy mit TLS-terminierten Routen für die S3-API und die Console bereit." --- -Use **Envoy** to terminate TLS and route separate hostnames to the RustFS S3 API and Console. This deployment runs Envoy and a single-node RustFS instance on one Docker network. You need Docker Engine, two DNS records, and a TLS certificate that covers both hostnames (the guide uses a self-signed certificate for testing). +Verwenden Sie **Envoy**, um TLS zu terminieren und getrennte Hostnamen zur RustFS-S3-API und zur Console (Weboberfläche) zu leiten. In dieser Bereitstellung betreiben Sie Envoy und eine RustFS-Instanz mit einem Knoten in einem Docker-Netzwerk. Sie benötigen Docker Engine, zwei DNS-Einträge und ein TLS-Zertifikat, das beide Hostnamen abdeckt (die Anleitung verwendet zum Testen ein selbst signiertes Zertifikat). -This guide uses these example hostnames: +Diese Anleitung verwendet diese Beispiel-Hostnamen: -- `s3.example.com` for the S3 API -- `console.example.com` for the Console +- `s3.example.com` für die S3-API +- `console.example.com` für die Console -Replace them with hostnames that resolve to the Docker host. +Ersetzen Sie sie durch Hostnamen, die auf den Docker-Host zeigen. -:::warning[Serve S3 from the root path] +:::warning[S3 vom Wurzelpfad bereitstellen] -Do not publish the S3 API under a path such as `/s3/`. AWS Signature Version 4 includes the request path and host, so rewriting either value can invalidate signed requests. Envoy forwards the incoming `Host` header unchanged, which keeps signatures valid. +Veröffentlichen Sie die S3-API nicht unter einem Pfad wie `/s3/`. AWS Signature Version 4 enthält den Anfragepfad und den Host, daher kann das Umschreiben eines der beiden Werte signierte Anfragen ungültig machen. Envoy leitet den eingehenden Header `Host` unverändert weiter, wodurch Signaturen gültig bleiben. ::: -## 1. Create the deployment directories +## 1. Die Bereitstellungsverzeichnisse anlegen -Create directories for the Envoy configuration and TLS certificate: +Legen Sie Verzeichnisse für die Envoy-Konfiguration und das TLS-Zertifikat an: ```bash mkdir -p rustfs-envoy/certs cd rustfs-envoy ``` -For local testing, generate a self-signed certificate covering both hostnames: +Erzeugen Sie für lokale Tests ein selbst signiertes Zertifikat, das beide Hostnamen abdeckt: ```bash openssl req -x509 -newkey rsa:2048 -nodes \ @@ -37,11 +37,11 @@ openssl req -x509 -newkey rsa:2048 -nodes \ chmod 644 certs/privkey.pem ``` -Make the certificate readable by the non-root user the Envoy image runs as — a `600` private key produces a misleading `Failed to load incomplete private key` error. +Machen Sie das Zertifikat für den Benutzer ohne Root-Rechte lesbar, unter dem das Envoy-Image läuft. Ein privater Schlüssel mit `600` erzeugt den irreführenden Fehler `Failed to load incomplete private key`. -## 2. Configure Envoy +## 2. Envoy konfigurieren -Create the configuration with an HTTPS listener and two virtual hosts. Route timeouts are disabled (`timeout: 0s`) so long streaming S3 uploads are not cut off: +Legen Sie die Konfiguration mit einem HTTPS-Listener und zwei virtuellen Hosts an. Route-Timeouts sind deaktiviert (`timeout: 0s`), damit lange Streaming-S3-Uploads nicht abgeschnitten werden: ```yaml title="envoy.yaml" static_resources: @@ -99,11 +99,11 @@ static_resources: - endpoint: {address: {socket_address: {address: rustfs, port_value: 9001}}} ``` -The `host:*` domain entries matter: clients send `Host: s3.example.com:8443` on non-standard ports, and Envoy matches the authority including the port. +Die Domäneneinträge `host:*` sind wichtig: Clients senden auf Nicht-Standard-Ports `Host: s3.example.com:8443`, und Envoy vergleicht die Authority einschließlich des Ports. -## 3. Start Envoy +## 3. Envoy starten -Run Envoy on the same Docker network as RustFS, publishing only the proxy port: +Starten Sie Envoy im selben Docker-Netzwerk wie RustFS und veröffentlichen Sie nur den Proxy-Port: ```bash docker run -d --name envoy --network oo-rustfs_default -p 8443:8443 \ @@ -112,9 +112,9 @@ docker run -d --name envoy --network oo-rustfs_default -p 8443:8443 \ envoyproxy/envoy:v1.34-latest -c /envoy.yaml ``` -## 4. Verify both endpoints +## 4. Beide Endpunkte prüfen -Point the example hostnames at the proxy with `curl --resolve` (in production, DNS does this): +Richten Sie die Beispiel-Hostnamen mit `curl --resolve` auf den Proxy (in der Produktion übernimmt das DNS): ```bash curl -sk --resolve s3.example.com:8443:127.0.0.1 \ @@ -129,11 +129,11 @@ s3 api: 200 console: 200 ``` -`-k` skips certificate validation because the certificate is self-signed; with a trusted certificate, drop it. +`-k` überspringt die Zertifikatsprüfung, weil das Zertifikat selbst signiert ist. Bei einem vertrauenswürdigen Zertifikat lassen Sie es weg. -## 5. Send signed S3 requests through Envoy +## 5. Signierte S3-Anfragen über Envoy senden -Point any S3 client at the proxy as if it were RustFS. Configure the client with `https://s3.example.com:8443` as the endpoint and path-style addressing; when the proxy certificate is trusted, signed AWS Signature Version 4 requests pass through unchanged. For a quick test over plain HTTP, add an HTTP listener on port 8080 with the same virtual-host routing as the HTTPS listener, then use the endpoint `http://s3.example.com:8080`: +Richten Sie einen beliebigen S3-Client auf den Proxy aus, als wäre er RustFS. Konfigurieren Sie den Client mit `https://s3.example.com:8443` als Endpunkt und mit pfadbasierter Adressierung (Path-Style). Wenn dem Proxy-Zertifikat vertraut wird, laufen signierte Anfragen mit AWS Signature Version 4 unverändert durch. Fügen Sie für einen schnellen Test über unverschlüsseltes HTTP einen HTTP-Listener auf Port 8080 mit demselben Virtual-Host-Routing wie der HTTPS-Listener hinzu und verwenden Sie dann den Endpunkt `http://s3.example.com:8080`: ```bash rc alias set rustfs-envoy http://s3.example.com:8080 @@ -145,11 +145,11 @@ rc ls rustfs-envoy/rclone-demo/ [2026-09-29 11:12:41] 5 B write-test.txt ``` -The signatures validate because Envoy forwards the original `Host` header to RustFS. +Die Signaturen bleiben gültig, weil Envoy den ursprünglichen Header `Host` an RustFS weiterleitet. -## Multi-node backends +## Backends mit mehreren Knoten -For a distributed RustFS deployment, add every node to the S3 cluster: +Fügen Sie für eine verteilte RustFS-Bereitstellung jeden Knoten zum S3-Cluster hinzu: ```yaml title="envoy.yaml" - name: rustfs_s3 @@ -169,24 +169,24 @@ For a distributed RustFS deployment, add every node to the S3 cluster: - endpoint: {address: {socket_address: {address: node4, port_value: 9000}}} ``` -The Console cluster follows the same pattern on port `9001`. +Der Console-Cluster folgt demselben Muster auf Port `9001`. -## Troubleshooting +## Fehlerbehebung ### `Failed to load incomplete private key from path` -The Envoy container runs as a non-root user and cannot read a `600` root-owned key. `chmod 644` the key files (or chown them to the container user, UID `1001` in the official image). +Der Envoy-Container läuft als Benutzer ohne Root-Rechte und kann einen root-eigenen Schlüssel mit `600` nicht lesen. Setzen Sie die Schlüsseldateien mit `chmod 644` (oder ändern Sie den Eigentümer auf den Container-Benutzer, UID `1001` im offiziellen Image). -### Routes return `404` with the correct hostnames +### Routen antworten mit `404` bei den richtigen Hostnamen -Envoy matches the authority including the port. Add the `host:*` variants to each virtual host's `domains` list, as in the configuration above. +Envoy vergleicht die Authority einschließlich des Ports. Fügen Sie die Varianten `host:*` zur Liste `domains` jedes virtuellen Hosts hinzu, wie in der Konfiguration oben. -### `Access Denied` from RustFS on proxied requests +### `Access Denied` von RustFS bei weitergeleiteten Anfragen -Confirm the proxy is not rewriting the path or the `Host` header. Signed requests must reach RustFS with the host the client signed for. +Prüfen Sie, dass der Proxy den Pfad und den Header `Host` nicht umschreibt. Signierte Anfragen müssen RustFS mit dem Host erreichen, für den der Client signiert hat. -## Next steps +## Nächste Schritte -- [Configure an S3 client](/developer/examples/aws-cli) -- [Enable virtual-hosted-style bucket URLs](/integration/virtual) -- [Review health and readiness endpoints](/operations/status-check) +- [Einen S3-Client konfigurieren](/de/developer/examples/aws-cli) +- [Bucket-URLs mit Adressierung im Virtual-Hosted-Stil aktivieren](/de/integration/virtual) +- [Endpunkte für Integritätsprüfung und Bereitschaft prüfen](/de/operations/status-check) diff --git a/content/de/developer/integration/reverse-proxy/haproxy.md b/content/de/developer/integration/reverse-proxy/haproxy.md index 87bf2a760..7e0990552 100644 --- a/content/de/developer/integration/reverse-proxy/haproxy.md +++ b/content/de/developer/integration/reverse-proxy/haproxy.md @@ -1,55 +1,55 @@ --- title: "HAProxy" -description: "Deploy RustFS behind HAProxy with separate HTTPS routes for the S3 API and Console." +description: "Stellen Sie RustFS hinter HAProxy mit getrennten HTTPS-Routen für die S3-API und die Console bereit." --- -Use **HAProxy** to terminate TLS and route separate hostnames to the RustFS S3 API and Console. This deployment runs HAProxy and a single-node RustFS instance with Docker Compose. You need Docker Engine, Docker Compose, two DNS records, and a TLS certificate that covers both hostnames. +Verwenden Sie **HAProxy**, um TLS zu terminieren und getrennte Hostnamen zur RustFS-S3-API und zur Console (Weboberfläche) zu leiten. In dieser Bereitstellung betreiben Sie HAProxy und eine RustFS-Instanz mit einem Knoten unter Docker Compose. Sie benötigen Docker Engine, Docker Compose, zwei DNS-Einträge und ein TLS-Zertifikat, das beide Hostnamen abdeckt. -This guide uses these example hostnames: +Diese Anleitung verwendet diese Beispiel-Hostnamen: -- `s3.example.com` for the S3 API -- `console.example.com` for the Console +- `s3.example.com` für die S3-API +- `console.example.com` für die Console -Replace them with hostnames that resolve to the Docker host. +Ersetzen Sie sie durch Hostnamen, die auf den Docker-Host zeigen. -:::warning[Serve S3 from the root path] +:::warning[S3 vom Wurzelpfad bereitstellen] -Do not publish the S3 API under a path such as `/s3/`. AWS Signature Version 4 includes the request path and host, so rewriting either value can invalidate signed requests. +Veröffentlichen Sie die S3-API nicht unter einem Pfad wie `/s3/`. AWS Signature Version 4 enthält den Anfragepfad und den Host, daher kann das Umschreiben eines der beiden Werte signierte Anfragen ungültig machen. ::: -## 1. Create the deployment directories +## 1. Die Bereitstellungsverzeichnisse anlegen -Create directories for the HAProxy configuration and TLS certificate: +Legen Sie Verzeichnisse für die HAProxy-Konfiguration und das TLS-Zertifikat an: ```bash mkdir -p rustfs-haproxy/config rustfs-haproxy/certs cd rustfs-haproxy ``` -HAProxy expects the certificate chain and private key in one PEM file. Combine them in this order: +HAProxy erwartet die Zertifikatskette und den privaten Schlüssel in einer PEM-Datei. Verbinden Sie sie in dieser Reihenfolge: ```bash cat fullchain.pem privkey.pem > certs/rustfs.pem chmod 600 certs/rustfs.pem ``` -The certificate must cover both public hostnames. +Das Zertifikat muss beide öffentlichen Hostnamen abdecken. -## 2. Set RustFS credentials +## 2. RustFS-Zugangsdaten setzen -Create an environment file and replace both credential placeholders: +Legen Sie eine Umgebungsdatei an und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Do not commit this file or the certificate private key to source control. +Nehmen Sie diese Datei und den privaten Schlüssel des Zertifikats nicht in die Versionsverwaltung auf. -## 3. Configure HAProxy +## 3. HAProxy konfigurieren -Create the HAProxy configuration: +Legen Sie die HAProxy-Konfiguration an: ```text title="config/haproxy.cfg" global @@ -96,13 +96,13 @@ backend rustfs_console server rustfs rustfs:9001 check inter 10s fall 3 rise 2 cookie rustfs ``` -HAProxy preserves the incoming host and request path unless you explicitly rewrite them. The long client, server, and tunnel timeouts accommodate streaming S3 operations and Console WebSocket connections. +HAProxy behält den eingehenden Host und den Anfragepfad bei, solange Sie sie nicht ausdrücklich umschreiben. Die langen Timeouts für Client, Server und Tunnel nehmen Streaming-S3-Operationen und Console-WebSocket-Verbindungen auf. -The Console backend sets an affinity cookie. With one RustFS server it has no routing effect, but keeping it in the base configuration makes the behavior consistent when you add nodes. +Das Console-Backend setzt ein Affinitäts-Cookie. Bei einem RustFS-Server hat es keine Routing-Wirkung, aber wenn Sie es in der Grundkonfiguration belassen, bleibt das Verhalten gleich, sobald Sie Knoten hinzufügen. -## 4. Create the Compose file +## 4. Die Compose-Datei anlegen -Create the HAProxy and RustFS services: +Legen Sie die Dienste HAProxy und RustFS an: ```yaml title="compose.yaml" services: @@ -153,58 +153,58 @@ networks: rustfs: ``` -Only HAProxy publishes host ports. RustFS ports `9000` and `9001` remain reachable inside the Compose network. +Nur HAProxy veröffentlicht Host-Ports. Die RustFS-Ports `9000` und `9001` bleiben innerhalb des Compose-Netzwerks erreichbar. -## 5. Validate and start the deployment +## 5. Die Bereitstellung prüfen und starten -Render the Compose configuration and start RustFS: +Rendern Sie die Compose-Konfiguration und starten Sie RustFS: ```bash docker compose config docker compose up -d rustfs ``` -Validate the HAProxy configuration with the same image used by the deployment: +Prüfen Sie die HAProxy-Konfiguration mit demselben Image, das die Bereitstellung verwendet: ```bash docker compose run --rm --no-deps haproxy haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg ``` -Start HAProxy and check both services: +Starten Sie HAProxy und prüfen Sie beide Dienste: ```bash docker compose up -d haproxy docker compose ps ``` -If a service does not become healthy, inspect its logs: +Wenn ein Dienst nicht gesund wird, prüfen Sie seine Logs: ```bash docker compose logs haproxy docker compose logs rustfs ``` -## 6. Verify both endpoints +## 6. Beide Endpunkte prüfen -Verify the API and Console through their public HTTPS hostnames: +Prüfen Sie die API und die Console über ihre öffentlichen HTTPS-Hostnamen: ```bash curl --fail https://s3.example.com/health/ready curl --fail https://console.example.com/rustfs/console/health ``` -Configure S3 clients with `https://s3.example.com` as the endpoint and enable path-style addressing. Open `https://console.example.com/rustfs/console/` to sign in to the Console. +Konfigurieren Sie S3-Clients mit `https://s3.example.com` als Endpunkt und aktivieren Sie pfadbasierte Adressierung (Path-Style). Öffnen Sie `https://console.example.com/rustfs/console/`, um sich an der Console anzumelden. -When you replace a renewed `certs/rustfs.pem`, validate the configuration and recreate the HAProxy container to load it: +Wenn Sie eine erneuerte Datei `certs/rustfs.pem` ersetzen, prüfen Sie die Konfiguration und erstellen Sie den HAProxy-Container neu, um sie zu laden: ```bash docker compose run --rm --no-deps haproxy haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg docker compose up -d --force-recreate haproxy ``` -## Multi-node backends +## Backends mit mehreren Knoten -For a distributed RustFS deployment, add every RustFS node to both backends: +Fügen Sie für eine verteilte RustFS-Bereitstellung jeden RustFS-Knoten zu beiden Backends hinzu: ```text title="config/haproxy.cfg" backend rustfs_s3 @@ -227,10 +227,10 @@ backend rustfs_console server node4 node4.example.net:9001 check inter 10s fall 3 rise 2 cookie node4 ``` -The Console cookie keeps an in-progress OpenID Connect login on the RustFS node that created its `state`. Keep port `9000` open directly between RustFS nodes because internal node RPC uses the same listener. +Das Console-Cookie hält eine laufende OpenID-Connect-Anmeldung auf dem RustFS-Knoten, der ihren `state` erzeugt hat. Halten Sie Port `9000` direkt zwischen den RustFS-Knoten offen, weil der interne Knoten-RPC denselben Listener verwendet. -## Next steps +## Nächste Schritte -- [Configure an S3 client](/developer/examples/aws-cli) -- [Enable virtual-hosted-style bucket URLs](/integration/virtual) -- [Review health and readiness endpoints](/operations/status-check) \ No newline at end of file +- [Einen S3-Client konfigurieren](/de/developer/examples/aws-cli) +- [Bucket-URLs mit Adressierung im Virtual-Hosted-Stil aktivieren](/de/integration/virtual) +- [Endpunkte für Integritätsprüfung und Bereitschaft prüfen](/de/operations/status-check) diff --git a/content/de/developer/integration/reverse-proxy/httpd.md b/content/de/developer/integration/reverse-proxy/httpd.md index d98ce20de..15f377555 100644 --- a/content/de/developer/integration/reverse-proxy/httpd.md +++ b/content/de/developer/integration/reverse-proxy/httpd.md @@ -1,33 +1,33 @@ --- title: "Apache HTTP Server" -description: "Deploy RustFS behind Apache HTTP Server with TLS termination for separate S3 API and Console hostnames." +description: "Stellen Sie RustFS hinter dem Apache HTTP Server mit TLS-Terminierung für getrennte Hostnamen der S3-API und der Console bereit." --- -Use **Apache HTTP Server** (httpd) to terminate TLS and route separate hostnames to the RustFS S3 API and Console. This deployment runs httpd and a single-node RustFS instance with Docker Compose. You need Docker Engine, Docker Compose, two DNS records, and a TLS certificate that covers both hostnames. +Verwenden Sie **Apache HTTP Server** (httpd), um TLS zu terminieren und getrennte Hostnamen zur RustFS-S3-API und zur Console (Weboberfläche) zu leiten. In dieser Bereitstellung betreiben Sie httpd und eine RustFS-Instanz mit einem Knoten unter Docker Compose. Sie benötigen Docker Engine, Docker Compose, zwei DNS-Einträge und ein TLS-Zertifikat, das beide Hostnamen abdeckt. -This guide uses these example hostnames: +Diese Anleitung verwendet diese Beispiel-Hostnamen: -- `s3.example.com` for the S3 API -- `console.example.com` for the Console +- `s3.example.com` für die S3-API +- `console.example.com` für die Console -Replace them with hostnames that resolve to the Docker host. +Ersetzen Sie sie durch Hostnamen, die auf den Docker-Host zeigen. -:::warning[Serve S3 from the root path] +:::warning[S3 vom Wurzelpfad bereitstellen] -Do not publish the S3 API under a path such as `/s3/`. AWS Signature Version 4 includes the request path and host, so rewriting either value can invalidate signed requests. Apache rewrites proxied URLs unless you disable canonicalization, which this configuration does with `nocanon`. +Veröffentlichen Sie die S3-API nicht unter einem Pfad wie `/s3/`. AWS Signature Version 4 enthält den Anfragepfad und den Host, daher kann das Umschreiben eines der beiden Werte signierte Anfragen ungültig machen. Apache schreibt weitergeleitete URLs um, solange Sie die Kanonisierung nicht abschalten. Diese Konfiguration tut das mit `nocanon`. ::: -## 1. Create the deployment directories +## 1. Die Bereitstellungsverzeichnisse anlegen -Create directories for the httpd configuration and TLS certificate: +Legen Sie Verzeichnisse für die httpd-Konfiguration und das TLS-Zertifikat an: ```bash mkdir -p rustfs-httpd/config rustfs-httpd/certs cd rustfs-httpd ``` -Copy your certificate chain and private key into `certs/`: +Kopieren Sie Ihre Zertifikatskette und den privaten Schlüssel nach `certs/`: ```text rustfs-httpd/ @@ -37,28 +37,28 @@ rustfs-httpd/ └── config/ ``` -Restrict access to the private key: +Schränken Sie den Zugriff auf den privaten Schlüssel ein: ```bash chmod 600 certs/privkey.pem ``` -The certificate must cover both public hostnames. +Das Zertifikat muss beide öffentlichen Hostnamen abdecken. -## 2. Set RustFS credentials +## 2. RustFS-Zugangsdaten setzen -Create an environment file and replace both credential placeholders: +Legen Sie eine Umgebungsdatei an und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Do not commit this file to source control. +Nehmen Sie diese Datei nicht in die Versionsverwaltung auf. -## 3. Build the httpd image +## 3. Das httpd-Image bauen -The stock `httpd` image ships with its proxy and TLS modules commented out. Build a small image that enables them and loads the RustFS virtual hosts: +Das Standard-Image `httpd` liefert seine Proxy- und TLS-Module auskommentiert aus. Bauen Sie ein kleines Image, das sie aktiviert und die virtuellen Hosts von RustFS lädt: ```dockerfile title="Dockerfile" FROM httpd:2.4-alpine @@ -79,11 +79,11 @@ RUN sed -i \ && printf '\nInclude conf/rustfs.conf\n' >> /usr/local/apache2/conf/httpd.conf ``` -`proxy_balancer`, `slotmem_shm`, and `lbmethod_byrequests` are only used by the [multi-node](#multi-node-backends) configuration. Loading them on single-node deployments is harmless. +`proxy_balancer`, `slotmem_shm` und `lbmethod_byrequests` verwendet nur die Konfiguration [mit mehreren Knoten](#backends-mit-mehreren-knoten). Sie auf Bereitstellungen mit einem Knoten zu laden, ist unschädlich. -## 4. Configure Apache HTTP Server +## 4. Apache HTTP Server konfigurieren -Create the httpd configuration with one virtual host per RustFS endpoint: +Legen Sie die httpd-Konfiguration mit einem virtuellen Host je RustFS-Endpunkt an: ```apache title="config/rustfs.conf" # Global settings shared by the RustFS virtual hosts. @@ -161,11 +161,11 @@ LimitRequestBody 0 ``` -`Listen 443` is required because the stock `httpd.conf` only opens port `80`; virtual hosts alone do not open ports. The two `VirtualHost *:80` blocks redirect all plain-HTTP traffic to HTTPS with explicit target hostnames. +`Listen 443` ist erforderlich, weil die mitgelieferte `httpd.conf` nur Port `80` öffnet. Virtuelle Hosts allein öffnen keine Ports. Die beiden Blöcke `VirtualHost *:80` leiten den gesamten unverschlüsselten HTTP-Verkehr mit ausdrücklichen Ziel-Hostnamen auf HTTPS um. -## 5. Create the Compose file +## 5. Die Compose-Datei anlegen -Create the httpd and RustFS services: +Legen Sie die Dienste httpd und RustFS an: ```yaml title="compose.yaml" services: @@ -216,126 +216,126 @@ networks: rustfs: ``` -Only httpd publishes host ports. RustFS ports `9000` and `9001` remain reachable inside the Compose network. +Nur httpd veröffentlicht Host-Ports. Die RustFS-Ports `9000` und `9001` bleiben innerhalb des Compose-Netzwerks erreichbar. -:::note[RustFS log directory] +:::note[Log-Verzeichnis von RustFS] -`RUSTFS_OBS_LOG_DIRECTORY` must point to a directory the container can create. The RustFS image runs as a non-root user, so `/logs` works while paths under `/var/log` make the container exit at startup with `Permission denied`. +`RUSTFS_OBS_LOG_DIRECTORY` muss auf ein Verzeichnis zeigen, das der Container anlegen kann. Das RustFS-Image läuft als Benutzer ohne Root-Rechte, daher funktioniert `/logs`, während Pfade unter `/var/log` den Container beim Start mit `Permission denied` beenden. ::: -## 6. Validate and start the deployment +## 6. Die Bereitstellung prüfen und starten -Render the Compose configuration and start RustFS: +Rendern Sie die Compose-Konfiguration und starten Sie RustFS: ```bash docker compose config docker compose up -d rustfs ``` -Validate the httpd configuration with the same image used by the deployment: +Prüfen Sie die httpd-Konfiguration mit demselben Image, das die Bereitstellung verwendet: ```bash docker compose run --rm --no-deps httpd httpd -t ``` -Start httpd and check both services: +Starten Sie httpd und prüfen Sie beide Dienste: ```bash docker compose up -d httpd docker compose ps ``` -If a service does not become healthy, inspect its logs: +Wenn ein Dienst nicht gesund wird, prüfen Sie seine Logs: ```bash docker compose logs httpd docker compose logs rustfs ``` -## 7. Verify both endpoints +## 7. Beide Endpunkte prüfen -Verify the API and Console through their public HTTPS hostnames: +Prüfen Sie die API und die Console über ihre öffentlichen HTTPS-Hostnamen: ```bash curl --fail https://s3.example.com/health/ready curl --fail https://console.example.com/rustfs/console/health ``` -Configure S3 clients with `https://s3.example.com` as the endpoint and enable path-style addressing. Open `https://console.example.com/rustfs/console/` to sign in to the Console. +Konfigurieren Sie S3-Clients mit `https://s3.example.com` als Endpunkt und aktivieren Sie pfadbasierte Adressierung (Path-Style). Öffnen Sie `https://console.example.com/rustfs/console/`, um sich an der Console anzumelden. -:::note[Console root path] +:::note[Wurzelpfad der Console] -In RustFS v2.x the Console is served under the `/rustfs/console/` path prefix. Requesting the root path of the Console hostname returns an S3-style XML access-denied response, which is expected. +In RustFS v2.x wird die Console unter dem Pfadpräfix `/rustfs/console/` bereitgestellt. Eine Anfrage an den Wurzelpfad des Console-Hostnamens liefert eine XML-Antwort im S3-Stil mit Zugriffsverweigerung. Das ist erwartet. ::: -When you replace a renewed certificate or key in `certs/`, validate the configuration and reload httpd gracefully without dropping active transfers: +Wenn Sie ein erneuertes Zertifikat oder einen Schlüssel in `certs/` ersetzen, prüfen Sie die Konfiguration und laden Sie httpd graceful neu, ohne aktive Transfers abzubrechen: ```bash docker compose exec httpd httpd -t docker compose exec httpd httpd -k graceful ``` -## How this configuration preserves S3 signatures +## So erhält diese Konfiguration S3-Signaturen -AWS Signature Version 4 signs the HTTP method, the `Host` header, and the raw request path. Every directive below keeps one of those values byte-identical between the client and RustFS: +AWS Signature Version 4 signiert die HTTP-Methode, den Header `Host` und den rohen Anfragepfad. Jede der folgenden Direktiven hält einen dieser Werte bytegleich zwischen Client und RustFS: -- **`ProxyPreserveHost On`** keeps the client's `Host` header. With the default (`Off`), Apache rewrites `Host` to the backend host and RustFS answers `SignatureDoesNotMatch`. -- **`nocanon`** on the `ProxyPass` line passes the request path to RustFS without URL canonicalization. Without it, Apache rewrites paths during forwarding (for example collapsing `//`), and any signed path no longer matches. -- **`AllowEncodedSlashes NoDecode`** lets object keys containing `%2F` reach the proxy handlers instead of returning `404`, and keeps the encoding intact. -- **`RequestHeader set X-Forwarded-Proto "https"`** tells RustFS the original scheme. Apache's `ProxyAddHeaders` (default `On`) adds `X-Forwarded-For`, `X-Forwarded-Host`, and `X-Forwarded-Server`, but not `X-Forwarded-Proto`. +- **`ProxyPreserveHost On`** behält den Header `Host` des Clients. Mit dem Standard (`Off`) schreibt Apache `Host` auf den Backend-Host um, und RustFS antwortet mit `SignatureDoesNotMatch`. +- **`nocanon`** in der Zeile `ProxyPass` übergibt den Anfragepfad ohne URL-Kanonisierung an RustFS. Ohne diesen Wert schreibt Apache Pfade bei der Weiterleitung um (zum Beispiel durch das Zusammenziehen von `//`), und ein signierter Pfad passt nicht mehr. +- **`AllowEncodedSlashes NoDecode`** lässt Objektschlüssel mit `%2F` die Proxy-Handler erreichen, statt `404` zurückzugeben, und erhält die Kodierung. +- **`RequestHeader set X-Forwarded-Proto "https"`** teilt RustFS das ursprüngliche Schema mit. `ProxyAddHeaders` von Apache (Standard `On`) fügt `X-Forwarded-For`, `X-Forwarded-Host` und `X-Forwarded-Server` hinzu, aber nicht `X-Forwarded-Proto`. -Presigned URLs, multipart uploads, and browser POST uploads rely on the same path and host preservation and need no extra directives. +Vorsignierte URLs, mehrteilige Uploads und Browser-POST-Uploads beruhen auf derselben Erhaltung von Pfad und Host und brauchen keine weiteren Direktiven. -The Console virtual host adds `upgrade=websocket` to its `ProxyPass` line so that WebSocket upgrades are tunneled end to end. Since 2.4.47, `mod_proxy_http` handles the upgrade itself and only tunnels connections the backend accepts with `101 Switching Protocols`; the older `mod_proxy_wstunnel` module is deprecated. +Der virtuelle Host der Console fügt `upgrade=websocket` zu seiner Zeile `ProxyPass` hinzu, damit WebSocket-Upgrades Ende zu Ende getunnelt werden. Seit 2.4.47 übernimmt `mod_proxy_http` das Upgrade selbst und tunnelt nur Verbindungen, die das Backend mit `101 Switching Protocols` annimmt. Das ältere Modul `mod_proxy_wstunnel` ist veraltet. -## Request bodies, large objects, and timeouts +## Anfragekörper, große Objekte und Timeouts -Apache forwards request bodies to RustFS without a size limit and without writing them to the proxy's disk. Bodies that arrive with a `Content-Length` (what AWS CLI, AWS SDKs, and `mc` send) stream through as they arrive. Bodies that arrive with `Transfer-Encoding: chunked` are also forwarded as chunked encoding, which RustFS rejects — see the warnings below. +Apache leitet Anfragekörper ohne Größengrenze und ohne sie auf die Platte des Proxys zu schreiben an RustFS weiter. Körper, die mit einem `Content-Length` ankommen (das senden AWS CLI, AWS-SDKs und `mc`), werden gestreamt, sobald sie eintreffen. Körper mit `Transfer-Encoding: chunked` werden ebenfalls als Chunked Encoding weitergeleitet, was RustFS ablehnt. Siehe die Warnungen unten. -The timeout directives trade safety for long transfers: +Die Timeout-Direktiven tauschen Sicherheit gegen lange Transfers: -- **`Timeout 600`** covers connection I/O in both directions, so slow downloads and uploads are not cut mid-transfer. -- **`ProxyTimeout 600`** applies the same budget to the connection with RustFS. -- **`RequestReadTimeout`** bounds slow clients without punishing steady ones: a request is dropped only when headers stall or the body rate falls below `MinRate`. -- **`LimitRequestBody 0`** states the default explicitly: request bodies of any size are accepted. +- **`Timeout 600`** deckt die Verbindungs-Ein-/Ausgabe in beide Richtungen ab, damit langsame Downloads und Uploads nicht mitten im Transfer abbrechen. +- **`ProxyTimeout 600`** wendet dasselbe Budget auf die Verbindung mit RustFS an. +- **`RequestReadTimeout`** begrenzt langsame Clients, ohne stetige zu bestrafen: eine Anfrage wird nur verworfen, wenn Header stocken oder die Körperrate unter `MinRate` fällt. +- **`LimitRequestBody 0`** nennt den Standard ausdrücklich: Anfragekörper beliebiger Größe werden akzeptiert. -:::warning[Uploads must carry a Content-Length] +:::warning[Uploads müssen ein Content-Length tragen] -RustFS rejects request bodies forwarded as `Transfer-Encoding: chunked` with `400 UnexpectedContent` (`This request does not support content.`). Clients must upload with a `Content-Length`. All major S3 clients do this out of the box, so this only affects hand-rolled HTTP scripts that stream from a pipe. Apache's default body handling converts small chunked bodies to `Content-Length` in memory but forwards large ones as chunked, so such a client can appear to work for small files and fail for large ones. `SetEnv proxy-sendcl 1` converts chunked bodies to `Content-Length` as a fallback — at the cost of spooling each body to the proxy's disk first. +RustFS lehnt als `Transfer-Encoding: chunked` weitergeleitete Anfragekörper mit `400 UnexpectedContent` ab (`This request does not support content.`). Clients müssen mit einem `Content-Length` hochladen. Alle gängigen S3-Clients tun das von sich aus, daher betrifft das nur selbst geschriebene HTTP-Skripte, die aus einer Pipe streamen. Die Standardbehandlung von Körpern in Apache wandelt kleine Chunked-Körper im Speicher in `Content-Length` um, leitet große aber als Chunked weiter. Ein solcher Client kann bei kleinen Dateien funktionieren und bei großen scheitern. `SetEnv proxy-sendcl 1` wandelt Chunked-Körper als Rückfall in `Content-Length` um, zum Preis, dass jeder Körper zuerst auf die Platte des Proxys geschrieben wird. ::: -:::warning[Presigned URLs and the Content-Type header] +:::warning[Vorsignierte URLs und der Header Content-Type] -A presigned URL fixes the headers covered by its signature. If the URL was generated without a `Content-Type`, the upload must not add one — RustFS answers `403 SignatureDoesNotMatch` for the unsigned header. Note that `curl -d` and `curl --data-binary` add `Content-Type: application/x-www-form-urlencoded` on their own. When the upload sends a `Content-Type`, presign the URL with the same value (the `ContentType` parameter in AWS SDKs) and make the request match it exactly. +Eine vorsignierte URL legt die Header fest, die ihre Signatur abdeckt. Wenn die URL ohne `Content-Type` erzeugt wurde, darf der Upload keinen hinzufügen. RustFS antwortet mit `403 SignatureDoesNotMatch` für den unsignierten Header. `curl -d` und `curl --data-binary` fügen von sich aus `Content-Type: application/x-www-form-urlencoded` hinzu. Wenn der Upload einen `Content-Type` sendet, signieren Sie die URL mit demselben Wert (der Parameter `ContentType` in den AWS-SDKs) vor und lassen Sie die Anfrage genau dazu passen. ::: -## Settings that do not suit RustFS +## Einstellungen, die nicht zu RustFS passen -The following Apache defaults and options break S3 semantics or waste resources. This configuration avoids all of them. +Die folgenden Apache-Standardwerte und Optionen brechen die S3-Semantik oder verschwenden Ressourcen. Diese Konfiguration vermeidet sie alle. -| Setting | Effect on RustFS | +| Einstellung | Auswirkung auf RustFS | | --- | --- | -| `ProxyPreserveHost Off` (default) | Rewrites `Host`; signed requests fail with `SignatureDoesNotMatch`. | -| `ProxyPass` without `nocanon` | Canonicalizes the request path; signed paths fail to verify. | -| `AllowEncodedSlashes Off` (default) | Returns `404` for object keys containing `%2F`. | -| Path prefixes (`ProxyPass /s3/`, `Alias`, rewrite rules) | Rewrites the request path; keep the S3 API on the root path. | -| `ProxyErrorOverride On` | Replaces RustFS S3 XML errors with Apache error pages; S3 SDKs cannot parse them. | -| `SetEnv proxy-sendcl 1`, `SetEnv force-proxy-request-1.0 1` | Forces a `Content-Length` upstream and spools chunked request bodies to disk before forwarding. It rescues chunked-only clients but adds disk I/O to large uploads. | -| `SetEnv proxy-sendchunked 1` | Forces chunked encoding upstream, which RustFS rejects with `400 UnexpectedContent`. | -| `mod_proxy_wstunnel` (`ProxyPass ... ws://`) | Deprecated since 2.4.47; use `upgrade=websocket` on `mod_proxy_http` instead. | +| `ProxyPreserveHost Off` (Standard) | Schreibt `Host` um; signierte Anfragen scheitern mit `SignatureDoesNotMatch`. | +| `ProxyPass` ohne `nocanon` | Kanonisiert den Anfragepfad; signierte Pfade lassen sich nicht prüfen. | +| `AllowEncodedSlashes Off` (Standard) | Liefert `404` für Objektschlüssel, die `%2F` enthalten. | +| Pfadpräfixe (`ProxyPass /s3/`, `Alias`, Rewrite-Regeln) | Schreibt den Anfragepfad um; belassen Sie die S3-API auf dem Wurzelpfad. | +| `ProxyErrorOverride On` | Ersetzt S3-XML-Fehler von RustFS durch Apache-Fehlerseiten; S3-SDKs können sie nicht lesen. | +| `SetEnv proxy-sendcl 1`, `SetEnv force-proxy-request-1.0 1` | Erzwingt upstream ein `Content-Length` und schreibt Chunked-Anfragekörper vor der Weiterleitung auf die Platte. Das rettet Clients, die nur Chunked können, fügt großen Uploads aber Platten-Ein-/Ausgabe hinzu. | +| `SetEnv proxy-sendchunked 1` | Erzwingt upstream Chunked Encoding, das RustFS mit `400 UnexpectedContent` ablehnt. | +| `mod_proxy_wstunnel` (`ProxyPass ... ws://`) | Seit 2.4.47 veraltet; verwenden Sie `upgrade=websocket` auf `mod_proxy_http`. | -Two RustFS-side limits are worth marking because no proxy setting can remove them: +Zwei Grenzen auf der RustFS-Seite sollten markiert bleiben, weil keine Proxy-Einstellung sie aufheben kann: -- Object keys containing empty (`//`) or dot (`.`) path segments are rejected with `InvalidArgument` even without a proxy. -- In RustFS v2.x the Console lives under `/rustfs/console/`; the Console root path answers with S3-style XML. +- Objektschlüssel mit leeren (`//`) oder Punkt-Pfadsegmenten (`.`) werden auch ohne Proxy mit `InvalidArgument` abgelehnt. +- In RustFS v2.x liegt die Console unter `/rustfs/console/`. Der Wurzelpfad der Console antwortet mit XML im S3-Stil. -## Multi-node backends +## Backends mit mehreren Knoten -For a distributed RustFS deployment, replace each single `ProxyPass` target with a balancer that lists every RustFS node. Replace the S3 virtual host's proxy block with: +Ersetzen Sie für eine verteilte RustFS-Bereitstellung jedes einzelne Ziel `ProxyPass` durch einen Balancer, der jeden RustFS-Knoten auflistet. Ersetzen Sie den Proxy-Block des virtuellen S3-Hosts durch: ```apache title="config/rustfs.conf" @@ -349,7 +349,7 @@ For a distributed RustFS deployment, replace each single `ProxyPass` target with ProxyPassReverse / balancer://s3/ ``` -Replace the Console virtual host's proxy block with: +Ersetzen Sie den Proxy-Block des virtuellen Console-Hosts durch: ```apache title="config/rustfs.conf" # Keep an in-progress login on the node that created its state. @@ -366,10 +366,10 @@ Replace the Console virtual host's proxy block with: ProxyPassReverse / balancer://console/ ``` -The `ROUTEID` cookie keeps an in-progress OpenID Connect login on the RustFS node that created its `state`. Keep `upgrade=websocket` on each `BalancerMember` line; `ProxySet` does not accept that parameter. Keep port `9000` open directly between RustFS nodes because internal node RPC uses the same listener. +Das Cookie `ROUTEID` hält eine laufende OpenID-Connect-Anmeldung auf dem RustFS-Knoten, der ihren `state` erzeugt hat. Belassen Sie `upgrade=websocket` in jeder Zeile `BalancerMember`. `ProxySet` akzeptiert diesen Parameter nicht. Halten Sie Port `9000` direkt zwischen den RustFS-Knoten offen, weil der interne Knoten-RPC denselben Listener verwendet. -## Next steps +## Nächste Schritte -- [Configure an S3 client](/developer/examples/aws-cli) -- [Enable virtual-hosted-style bucket URLs](/integration/virtual) -- [Review health and readiness endpoints](/operations/status-check) +- [Einen S3-Client konfigurieren](/de/developer/examples/aws-cli) +- [Bucket-URLs mit Adressierung im Virtual-Hosted-Stil aktivieren](/de/integration/virtual) +- [Endpunkte für Integritätsprüfung und Bereitschaft prüfen](/de/operations/status-check) diff --git a/content/de/developer/integration/reverse-proxy/index.md b/content/de/developer/integration/reverse-proxy/index.md index 397cdad64..1f82173b4 100644 --- a/content/de/developer/integration/reverse-proxy/index.md +++ b/content/de/developer/integration/reverse-proxy/index.md @@ -1,13 +1,13 @@ --- -title: "Reverse Proxy" -description: "Choose and configure a reverse proxy for the RustFS S3 API and Console." +title: "Reverse-Proxy" +description: "Wählen und konfigurieren Sie einen Reverse-Proxy für die RustFS-S3-API und die Console." --- -Use a reverse proxy to expose the **RustFS** S3 API and Console through managed hostnames and TLS endpoints. +Verwenden Sie einen Reverse-Proxy, um die **RustFS**-S3-API und die Console (Weboberfläche) über verwaltete Hostnamen und TLS-Endpunkte bereitzustellen. -We recommend using separate hostnames for the S3 API on port `9000` and the Console on port `9001`. Serve the S3 API from the root of its hostname because S3 clients sign the request path. +Wir empfehlen getrennte Hostnamen für die S3-API auf Port `9000` und die Console auf Port `9001`. Stellen Sie die S3-API vom Wurzelpfad ihres Hostnamens bereit, weil S3-Clients den Anfragepfad signieren. -## Supported guides +## Unterstützte Anleitungen - [Nginx](./nginx.md) - [Traefik](./traefik.md) @@ -16,6 +16,6 @@ We recommend using separate hostnames for the S3 API on port `9000` and the Cons - [Envoy](./envoy.md) - [Apache HTTP Server](./httpd.md) -## Related configuration +## Zugehörige Konfiguration -See [Virtual-Host Access](/integration/virtual) when clients access buckets through virtual-hosted-style URLs. \ No newline at end of file +Siehe [Virtual-Host-Zugriff](/de/integration/virtual), wenn Clients Buckets über URLs mit Adressierung im Virtual-Hosted-Stil ansprechen. diff --git a/content/de/developer/integration/reverse-proxy/meta.json b/content/de/developer/integration/reverse-proxy/meta.json index 47c8243f7..3637b431b 100644 --- a/content/de/developer/integration/reverse-proxy/meta.json +++ b/content/de/developer/integration/reverse-proxy/meta.json @@ -1,5 +1,5 @@ { - "title": "Reverse Proxy", + "title": "Reverse-Proxy", "pages": [ "nginx", "traefik", diff --git a/content/de/developer/integration/reverse-proxy/nginx.md b/content/de/developer/integration/reverse-proxy/nginx.md index 5246711c6..ebd4ce901 100644 --- a/content/de/developer/integration/reverse-proxy/nginx.md +++ b/content/de/developer/integration/reverse-proxy/nginx.md @@ -1,33 +1,33 @@ --- title: "Nginx" -description: "Deploy RustFS behind Nginx with separate HTTPS endpoints for the S3 API and Console." +description: "Stellen Sie RustFS hinter Nginx mit getrennten HTTPS-Endpunkten für die S3-API und die Console bereit." --- -Use **Nginx** to terminate TLS and route separate hostnames to the RustFS S3 API and Console. This deployment runs Nginx and a single-node RustFS instance with Docker Compose. You need Docker Engine, Docker Compose, two DNS records, and a TLS certificate that covers both hostnames. +Verwenden Sie **Nginx**, um TLS zu terminieren und getrennte Hostnamen zur RustFS-S3-API und zur Console (Weboberfläche) zu leiten. In dieser Bereitstellung betreiben Sie Nginx und eine RustFS-Instanz mit einem Knoten unter Docker Compose. Sie benötigen Docker Engine, Docker Compose, zwei DNS-Einträge und ein TLS-Zertifikat, das beide Hostnamen abdeckt. -This guide uses these example hostnames: +Diese Anleitung verwendet diese Beispiel-Hostnamen: -- `s3.example.com` for the S3 API -- `console.example.com` for the Console +- `s3.example.com` für die S3-API +- `console.example.com` für die Console -Replace them with hostnames that resolve to the Docker host. +Ersetzen Sie sie durch Hostnamen, die auf den Docker-Host zeigen. -:::warning[Serve S3 from the root path] +:::warning[S3 vom Wurzelpfad bereitstellen] -Do not publish the S3 API under a path such as `/s3/`. AWS Signature Version 4 includes the request path and host, so rewriting either value can invalidate signed requests. +Veröffentlichen Sie die S3-API nicht unter einem Pfad wie `/s3/`. AWS Signature Version 4 enthält den Anfragepfad und den Host, daher kann das Umschreiben eines der beiden Werte signierte Anfragen ungültig machen. ::: -## 1. Create the deployment directories +## 1. Die Bereitstellungsverzeichnisse anlegen -Create directories for the Nginx configuration and TLS certificate: +Legen Sie Verzeichnisse für die Nginx-Konfiguration und das TLS-Zertifikat an: ```bash mkdir -p rustfs-nginx/sites rustfs-nginx/certs cd rustfs-nginx ``` -Copy your certificate chain and private key into `certs/`: +Kopieren Sie Ihre Zertifikatskette und den privaten Schlüssel nach `certs/`: ```text rustfs-nginx/ @@ -37,26 +37,26 @@ rustfs-nginx/ └── sites/ ``` -Restrict access to the private key: +Schränken Sie den Zugriff auf den privaten Schlüssel ein: ```bash chmod 600 certs/privkey.pem ``` -## 2. Set RustFS credentials +## 2. RustFS-Zugangsdaten setzen -Create an environment file and replace both credential placeholders: +Legen Sie eine Umgebungsdatei an und ersetzen Sie beide Platzhalter für die Zugangsdaten: ```ini title=".env" RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Do not commit this file to source control. +Nehmen Sie diese Datei nicht in die Versionsverwaltung auf. -## 3. Configure Nginx +## 3. Nginx konfigurieren -Create the Nginx configuration: +Legen Sie die Nginx-Konfiguration an: ```nginx title="sites/rustfs.conf" map $http_upgrade $connection_upgrade { @@ -137,11 +137,11 @@ server { } ``` -The S3 server preserves the original host and request path, disables request buffering for streaming uploads, and does not convert signed `HEAD` requests. The Console server also forwards WebSocket upgrade headers. +Der S3-Server behält den ursprünglichen Host und den Anfragepfad, deaktiviert die Anfragepufferung für Streaming-Uploads und wandelt signierte `HEAD`-Anfragen nicht um. Der Console-Server leitet außerdem die Header für WebSocket-Upgrades weiter. -## 4. Create the Compose file +## 4. Die Compose-Datei anlegen -Create the deployment definition: +Legen Sie die Bereitstellungsdefinition an: ```yaml title="compose.yaml" services: @@ -192,11 +192,11 @@ networks: rustfs: ``` -Only Nginx publishes host ports. RustFS ports `9000` and `9001` remain reachable inside the Compose network. +Nur Nginx veröffentlicht Host-Ports. Die RustFS-Ports `9000` und `9001` bleiben innerhalb des Compose-Netzwerks erreichbar. -## 5. Validate and start the deployment +## 5. Die Bereitstellung prüfen und starten -Validate both configuration files before starting the services: +Prüfen Sie beide Konfigurationsdateien, bevor Sie die Dienste starten: ```bash docker compose config @@ -204,41 +204,41 @@ docker compose up -d rustfs docker compose run --rm --no-deps nginx nginx -t ``` -Start Nginx and check both services: +Starten Sie Nginx und prüfen Sie beide Dienste: ```bash docker compose up -d nginx docker compose ps ``` -If a service does not become healthy, inspect its logs: +Wenn ein Dienst nicht gesund wird, prüfen Sie seine Logs: ```bash docker compose logs nginx docker compose logs rustfs ``` -## 6. Verify both endpoints +## 6. Beide Endpunkte prüfen -Verify the API and Console through their public HTTPS hostnames: +Prüfen Sie die API und die Console über ihre öffentlichen HTTPS-Hostnamen: ```bash curl --fail https://s3.example.com/health/ready curl --fail https://console.example.com/rustfs/console/health ``` -Configure S3 clients with `https://s3.example.com` as the endpoint and enable path-style addressing. Open `https://console.example.com/rustfs/console/` to sign in to the Console. +Konfigurieren Sie S3-Clients mit `https://s3.example.com` als Endpunkt und aktivieren Sie pfadbasierte Adressierung (Path-Style). Öffnen Sie `https://console.example.com/rustfs/console/`, um sich an der Console anzumelden. -When you replace a renewed certificate or key in `certs/`, validate and reload Nginx without interrupting active connections: +Wenn Sie ein erneuertes Zertifikat oder einen Schlüssel in `certs/` ersetzen, prüfen Sie Nginx und laden Sie es neu, ohne aktive Verbindungen zu unterbrechen: ```bash docker compose exec nginx nginx -t docker compose exec nginx nginx -s reload ``` -## Multi-node upstreams +## Upstreams mit mehreren Knoten -For a distributed RustFS deployment, replace the single server in each upstream with all RustFS nodes: +Ersetzen Sie für eine verteilte RustFS-Bereitstellung den einzelnen Server in jedem Upstream durch alle RustFS-Knoten: ```nginx title="sites/rustfs.conf" upstream rustfs_s3 { @@ -260,10 +260,10 @@ upstream rustfs_console { } ``` -The Console upstream uses client affinity because an in-progress OpenID Connect login stores its `state` on one RustFS node. Keep port `9000` open between RustFS nodes because internal node RPC uses the same listener. +Der Console-Upstream verwendet Client-Affinität, weil eine laufende OpenID-Connect-Anmeldung ihren `state` auf einem RustFS-Knoten speichert. Halten Sie Port `9000` zwischen den RustFS-Knoten offen, weil der interne Knoten-RPC denselben Listener verwendet. -## Next steps +## Nächste Schritte -- [Configure an S3 client](/developer/examples/aws-cli) -- [Enable virtual-hosted-style bucket URLs](/integration/virtual) -- [Review health and readiness endpoints](/operations/status-check) \ No newline at end of file +- [Einen S3-Client konfigurieren](/de/developer/examples/aws-cli) +- [Bucket-URLs mit Adressierung im Virtual-Hosted-Stil aktivieren](/de/integration/virtual) +- [Endpunkte für Integritätsprüfung und Bereitschaft prüfen](/de/operations/status-check) diff --git a/content/de/developer/integration/reverse-proxy/traefik.md b/content/de/developer/integration/reverse-proxy/traefik.md index 4d382cbc4..cd6a17734 100644 --- a/content/de/developer/integration/reverse-proxy/traefik.md +++ b/content/de/developer/integration/reverse-proxy/traefik.md @@ -1,26 +1,26 @@ --- title: "Traefik" -description: "Deploy RustFS behind Traefik with automatic TLS for separate S3 API and Console hostnames." +description: "Stellen Sie RustFS hinter Traefik mit automatischem TLS für getrennte Hostnamen der S3-API und der Console bereit." --- -Use **Traefik** and its Docker provider to discover RustFS, obtain TLS certificates from Let's Encrypt, and route separate hostnames to the S3 API and Console. You need Docker Engine, Docker Compose, a public server, and two DNS records that resolve to that server. +Verwenden Sie **Traefik** und seinen Docker-Provider, um RustFS zu entdecken, TLS-Zertifikate von Let's Encrypt zu beziehen und getrennte Hostnamen zur S3-API und zur Console (Weboberfläche) zu leiten. Sie benötigen Docker Engine, Docker Compose, einen öffentlichen Server und zwei DNS-Einträge, die auf diesen Server zeigen. -This guide uses these example hostnames: +Diese Anleitung verwendet diese Beispiel-Hostnamen: -- `s3.example.com` for the S3 API -- `console.example.com` for the Console +- `s3.example.com` für die S3-API +- `console.example.com` für die Console -Replace them with your public hostnames. The ACME HTTP-01 challenge requires inbound access to ports `80` and `443`. +Ersetzen Sie sie durch Ihre öffentlichen Hostnamen. Die ACME-Challenge HTTP-01 verlangt eingehenden Zugriff auf die Ports `80` und `443`. -:::warning[Serve S3 from the root path] +:::warning[S3 vom Wurzelpfad bereitstellen] -Do not publish the S3 API under a path such as `/s3/`. AWS Signature Version 4 includes the request path and host, so rewriting either value can invalidate signed requests. +Veröffentlichen Sie die S3-API nicht unter einem Pfad wie `/s3/`. AWS Signature Version 4 enthält den Anfragepfad und den Host, daher kann das Umschreiben eines der beiden Werte signierte Anfragen ungültig machen. ::: -## 1. Create the deployment directory +## 1. Das Bereitstellungsverzeichnis anlegen -Create a directory and an empty ACME storage file. Traefik requires restrictive permissions on this file: +Legen Sie ein Verzeichnis und eine leere ACME-Speicherdatei an. Traefik verlangt restriktive Berechtigungen für diese Datei: ```bash mkdir rustfs-traefik @@ -29,9 +29,9 @@ touch acme.json chmod 600 acme.json ``` -## 2. Set deployment variables +## 2. Bereitstellungsvariablen setzen -Create an environment file and replace each value: +Legen Sie eine Umgebungsdatei an und ersetzen Sie jeden Wert: ```ini title=".env" S3_HOSTNAME=s3.example.com @@ -41,11 +41,11 @@ RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -Use an email address that receives certificate expiration notices. Do not commit `.env` or `acme.json` to source control. +Verwenden Sie eine E-Mail-Adresse, die Hinweise zum Ablauf von Zertifikaten empfängt. Nehmen Sie `.env` und `acme.json` nicht in die Versionsverwaltung auf. -## 3. Create the Compose file +## 3. Die Compose-Datei anlegen -Create the Traefik and RustFS services: +Legen Sie die Dienste Traefik und RustFS an: ```yaml title="compose.yaml" services: @@ -126,51 +126,51 @@ networks: name: rustfs ``` -The two routers use different host rules and backend ports. RustFS does not publish ports `9000` or `9001` on the Docker host, and the Traefik Dashboard is not exposed. +Die beiden Router verwenden unterschiedliche Host-Regeln und Backend-Ports. RustFS veröffentlicht die Ports `9000` und `9001` nicht auf dem Docker-Host, und das Traefik-Dashboard wird nicht bereitgestellt. -:::note[Docker socket access] +:::note[Zugriff auf den Docker-Socket] -Traefik reads container labels through the read-only Docker socket mount. Anyone who can modify Docker workloads can influence routes discovered by the Docker provider. Restrict Docker access on the proxy host. +Traefik liest Container-Labels über den schreibgeschützten Mount des Docker-Sockets. Wer Docker-Workloads ändern kann, kann Routen beeinflussen, die der Docker-Provider entdeckt. Schränken Sie den Docker-Zugriff auf dem Proxy-Host ein. ::: -## 4. Validate and start the deployment +## 4. Die Bereitstellung prüfen und starten -Render the Compose configuration and check that all variables resolve: +Rendern Sie die Compose-Konfiguration und prüfen Sie, dass alle Variablen aufgelöst werden: ```bash docker compose config ``` -Start both services: +Starten Sie beide Dienste: ```bash docker compose up -d docker compose ps ``` -Follow the Traefik logs while it completes the ACME challenge and creates both certificates: +Folgen Sie den Traefik-Logs, während die ACME-Challenge abgeschlossen und beide Zertifikate erzeugt werden: ```bash docker compose logs --follow traefik ``` -If certificate issuance fails, confirm that both DNS records resolve to this host and that ports `80` and `443` are reachable from the internet. Let's Encrypt rate limits apply, so correct DNS and firewall problems before repeatedly recreating the deployment. +Wenn die Zertifikatsausstellung scheitert, prüfen Sie, dass beide DNS-Einträge auf diesen Host zeigen und dass die Ports `80` und `443` aus dem Internet erreichbar sind. Let's Encrypt wendet Ratenbegrenzungen an, beheben Sie daher DNS- und Firewall-Probleme, bevor Sie die Bereitstellung wiederholt neu erstellen. -## 5. Verify both endpoints +## 5. Beide Endpunkte prüfen -Verify the S3 API readiness endpoint and Console health endpoint through Traefik: +Prüfen Sie den Bereitschaftsendpunkt der S3-API und den Integritätsendpunkt der Console über Traefik: ```bash curl --fail https://s3.example.com/health/ready curl --fail https://console.example.com/rustfs/console/health ``` -Configure S3 clients with `https://s3.example.com` as the endpoint and enable path-style addressing. Open `https://console.example.com/rustfs/console/` to sign in to the Console. +Konfigurieren Sie S3-Clients mit `https://s3.example.com` als Endpunkt und aktivieren Sie pfadbasierte Adressierung (Path-Style). Öffnen Sie `https://console.example.com/rustfs/console/`, um sich an der Console anzumelden. -## Multi-node services +## Dienste mit mehreren Knoten -For an external multi-node RustFS cluster, enable Traefik's file provider in the `traefik` service: +Aktivieren Sie für einen externen RustFS-Cluster mit mehreren Knoten den File-Provider von Traefik im Dienst `traefik`: ```yaml title="compose.yaml" services: @@ -182,7 +182,7 @@ services: - ./dynamic.yaml:/etc/traefik/dynamic.yaml:ro ``` -Create the dynamic configuration with every RustFS node: +Legen Sie die dynamische Konfiguration mit jedem RustFS-Knoten an: ```yaml title="dynamic.yaml" http: @@ -234,10 +234,10 @@ http: - url: http://node4.example.net:9001 ``` -Configure sticky sessions for the Console service when you use OpenID Connect. An in-progress login stores its `state` on one RustFS node and the callback must return to that node. Keep port `9000` open directly between RustFS nodes because internal node RPC uses the same listener. +Konfigurieren Sie Sticky Sessions für den Console-Dienst, wenn Sie OpenID Connect verwenden. Eine laufende Anmeldung speichert ihren `state` auf einem RustFS-Knoten, und der Callback muss zu diesem Knoten zurückkehren. Halten Sie Port `9000` direkt zwischen den RustFS-Knoten offen, weil der interne Knoten-RPC denselben Listener verwendet. -## Next steps +## Nächste Schritte -- [Configure an S3 client](/developer/examples/aws-cli) -- [Enable virtual-hosted-style bucket URLs](/integration/virtual) -- [Review health and readiness endpoints](/operations/status-check) \ No newline at end of file +- [Einen S3-Client konfigurieren](/de/developer/examples/aws-cli) +- [Bucket-URLs mit Adressierung im Virtual-Hosted-Stil aktivieren](/de/integration/virtual) +- [Endpunkte für Integritätsprüfung und Bereitschaft prüfen](/de/operations/status-check) diff --git a/content/de/developer/integration/storage/alluxio.md b/content/de/developer/integration/storage/alluxio.md index df752710f..e878df9ad 100644 --- a/content/de/developer/integration/storage/alluxio.md +++ b/content/de/developer/integration/storage/alluxio.md @@ -1,13 +1,13 @@ --- title: "Alluxio" -description: "Cache RustFS buckets with Alluxio for faster reads." +description: "Cachen Sie RustFS-Buckets mit Alluxio für schnellere Lesevorgänge." --- -This guide connects [Alluxio](https://github.com/Alluxio/alluxio) — the distributed data orchestration layer — to **RustFS** as an under filesystem (UFS). You will run a standalone Alluxio cluster in Docker, mount a RustFS bucket, read an object through the cache, and write a file back to the bucket through Alluxio. The workflow was verified with Alluxio 2.9.4 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Alluxio](https://github.com/Alluxio/alluxio) — die verteilte Datenorchestrierungsschicht — mit **RustFS** als Under Filesystem (UFS). Sie betreiben einen eigenständigen Alluxio-Cluster in Docker, hängen einen RustFS-Bucket ein, lesen ein Objekt über den Cache und schreiben eine Datei über Alluxio zurück in den Bucket. Der Ablauf wurde mit Alluxio 2.9.4 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker with `--shm-size 2g` capacity (the worker uses a tmpfs ramdisk). +Sie benötigen Docker mit einer Kapazität von `--shm-size 2g` (der Worker verwendet eine tmpfs-Ramdisk). -## Architecture +## Architektur ```mermaid flowchart LR @@ -17,11 +17,11 @@ flowchart LR Writer["Alluxio writes"] -->|"persist"| RustFS ``` -Objects read once are cached in the worker's ramdisk; repeated reads are served from memory. Writes through Alluxio land in the bucket as regular objects. +Einmal gelesene Objekte werden in der Ramdisk des Workers gecacht. Wiederholte Lesevorgänge werden aus dem Speicher bedient. Schreibvorgänge über Alluxio landen im Bucket als gewöhnliche Objekte. -## 1. Run the master and worker +## 1. Master und Worker starten -The standalone image starts one process per invocation. Run the master first, then the worker: +Das Standalone-Image startet einen Prozess je Aufruf. Starten Sie zuerst den Master, dann den Worker: ```bash docker run -d --name alluxio-master --hostname alluxio --network oo-rustfs_default \ @@ -37,11 +37,11 @@ Capacity information for all workers: Total Capacity: 1024.00MB ``` -If the worker exits immediately with `tmpfs is smaller than the configured size`, the container was started without `--shm-size`. +Wenn der Worker sofort mit `tmpfs is smaller than the configured size` endet, wurde der Container ohne `--shm-size` gestartet. -## 2. Mount the RustFS bucket +## 2. Den RustFS-Bucket einhängen -The credential options must use the full `alluxio.underfs.s3.*` key names — short `s3a.*` or `aws.*` keys are accepted by the CLI but ignored by the UFS client: +Die Zugangsdatenoptionen müssen die vollständigen Schlüsselnamen `alluxio.underfs.s3.*` verwenden. Kurze Schlüssel `s3a.*` oder `aws.*` akzeptiert die CLI, der UFS-Client ignoriert sie aber: ```bash docker exec alluxio alluxio fs mount \ @@ -57,11 +57,11 @@ docker exec alluxio alluxio fs mount \ Mounted s3://alluxio-demo/ at /rustfs ``` -`disable.dns.buckets` forces path-style addressing, which the IP-style endpoint requires. +`disable.dns.buckets` erzwingt pfadbasierte Adressierung (Path-Style), die der Endpunkt im IP-Stil verlangt. -## 3. Read through the cache +## 3. Über den Cache lesen -List the mount and read a seeded object: +Listen Sie den Mount auf und lesen Sie ein vorbereitetes Objekt: ```bash docker exec alluxio alluxio fs ls /rustfs @@ -73,11 +73,11 @@ docker exec alluxio alluxio fs cat /rustfs/rustfs-test.txt hello from s3fs ``` -`PERSISTED` means the source of truth is in RustFS; the worker caches blocks after the first read. +`PERSISTED` bedeutet, dass die Quelle der Wahrheit in RustFS liegt. Der Worker cacht Blöcke nach dem ersten Lesevorgang. -## 4. Write through Alluxio +## 4. Über Alluxio schreiben -Copy a local file into the mount: +Kopieren Sie eine lokale Datei in den Mount: ```bash echo "written via alluxio cache to rustfs" > /tmp/rt.txt @@ -89,7 +89,7 @@ docker exec alluxio alluxio fs copyFromLocal /tmp/rt.txt /rustfs/alluxio-write.t Copied 'file:///tmp/rt.txt' to '/rustfs/alluxio-write.txt' ``` -Verify the object in RustFS: +Prüfen Sie das Objekt in RustFS: ```bash rc ls rustfs/alluxio-demo/ @@ -102,9 +102,9 @@ rc cat rustfs/alluxio-demo/alluxio-write.txt written via alluxio cache to rustfs ``` -![Alluxio-managed files stored in the RustFS Console](./images/rustfs-alluxio-mount.png) +![In der RustFS-Console gespeicherte, von Alluxio verwaltete Dateien](./images/rustfs-alluxio-mount.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen ```bash docker exec alluxio alluxio fs unmount /rustfs @@ -112,22 +112,22 @@ docker rm -f alluxio rc rm rustfs/alluxio-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### Worker exits with `tmpfs is smaller than the configured size` +### Der Worker endet mit `tmpfs is smaller than the configured size` -The worker places its ramdisk in `/dev/shm`, which Docker caps at 64 MB by default. Start the container with `--shm-size 2g` or lower `alluxio.worker.ramdisk.size`. +Der Worker legt seine Ramdisk in `/dev/shm` ab, das Docker standardmäßig auf 64 MB begrenzt. Starten Sie den Container mit `--shm-size 2g` oder senken Sie `alluxio.worker.ramdisk.size`. -### Mount succeeds but `fs ls` returns `InvalidAccessKeyId` +### Der Mount gelingt, `fs ls` liefert aber `InvalidAccessKeyId` -The mount options used short key names (`s3a.*`, `aws.*`). Alluxio's UFS client only honors the full `alluxio.underfs.s3.*` keys shown in step 2. +Die Mount-Optionen verwendeten kurze Schlüsselnamen (`s3a.*`, `aws.*`). Der UFS-Client von Alluxio berücksichtigt nur die vollständigen Schlüssel `alluxio.underfs.s3.*` aus Schritt 2. ### `S3 client v2 does not support global bucket access` -Path-style addressing is off. Add `--option alluxio.underfs.s3.disable.dns.buckets=true` — the IP-style RustFS endpoint requires it. +Die pfadbasierte Adressierung ist aus. Fügen Sie `--option alluxio.underfs.s3.disable.dns.buckets=true` hinzu. Der RustFS-Endpunkt im IP-Stil verlangt das. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional Alluxio UFS types. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [Alluxio documentation](https://docs.alluxio.io/os/user/stable/ufs/S3.html) for cache policies, TTLs, and multi-tier storage on top of the same bucket. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere Alluxio-UFS-Typen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [Alluxio-Dokumentation](https://docs.alluxio.io/os/user/stable/ufs/S3.html) für Cache-Policies, TTLs und mehrstufigen Speicher auf demselben Bucket. diff --git a/content/de/developer/integration/storage/index.md b/content/de/developer/integration/storage/index.md index 885c83dbc..b037a2882 100644 --- a/content/de/developer/integration/storage/index.md +++ b/content/de/developer/integration/storage/index.md @@ -1,11 +1,11 @@ --- -title: "Storage" -description: "Use RustFS as the S3 backend for storage systems and storage gateways." +title: "Speicher" +description: "Nutzen Sie RustFS als S3-Backend für Speichersysteme und Speicher-Gateways." --- -Use **RustFS** as the backend for storage systems and gateways built on top of object storage. +Nutzen Sie **RustFS** als Backend für Speichersysteme und Gateways, die auf Objektspeicher aufsetzen. -## Systems +## Systeme - [lakeFS](./lakefs.md) - [OpenDAL](./opendal.md) @@ -14,4 +14,4 @@ Use **RustFS** as the backend for storage systems and gateways built on top of o - [SFTPGo](./sftpgo.md) - [Alluxio](./alluxio.md) -Use a dedicated bucket and prefix per system, and scope credentials to the required bucket operations. +Verwenden Sie je System einen eigenen Bucket und ein eigenes Präfix und beschränken Sie die Zugangsdaten auf die erforderlichen Bucket-Operationen. diff --git a/content/de/developer/integration/storage/lakefs.md b/content/de/developer/integration/storage/lakefs.md index ba63ef224..f7dfec4a8 100644 --- a/content/de/developer/integration/storage/lakefs.md +++ b/content/de/developer/integration/storage/lakefs.md @@ -1,13 +1,13 @@ --- title: "lakeFS" -description: "Run lakeFS with RustFS as its S3 blockstore for versioned data lakes." +description: "Betreiben Sie lakeFS mit RustFS als S3-Blockstore für versionierte Data Lakes." --- -This guide connects [lakeFS](https://github.com/treeverse/lakeFS) — the Git-like data lake versioning layer — to **RustFS** as its S3 blockstore. You will start lakeFS, create a repository whose storage namespace points at a RustFS bucket, commit an object, and verify that the lakeFS metadata and data files live in RustFS. The workflow was verified with `treeverse/lakefs:1.58.0` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [lakeFS](https://github.com/treeverse/lakeFS) — die Git-ähnliche Versionierungsschicht für Data Lakes — mit **RustFS** als S3-Blockstore. Sie starten lakeFS, legen ein Repository an, dessen Storage-Namespace auf einen RustFS-Bucket zeigt, committen ein Objekt und prüfen, dass die Metadaten und Datendateien von lakeFS in RustFS liegen. Der Ablauf wurde mit `treeverse/lakefs:1.58.0` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker. This deployment is intended for local integration testing, not production. +Sie benötigen Docker. Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR LakeFS -->|"metadata + data"| RustFS["RustFS :9000"] ``` -lakeFS stores repository metadata and committed data files in the blockstore under the storage namespace. The bucket holds one `repo/` prefix containing `_lakefs/` metadata and `data/` objects; lakeFS reads and writes them through the S3 API. +lakeFS speichert Repository-Metadaten und committete Datendateien im Blockstore unter dem Storage-Namespace. Der Bucket enthält ein Präfix `repo/` mit Metadaten `_lakefs/` und Objekten `data/`. lakeFS liest und schreibt sie über die S3-API. -## 1. Create the project files +## 1. Projektdateien anlegen -Create the bucket, then the lakeFS configuration: +Legen Sie den Bucket an und danach die lakeFS-Konfiguration: ```bash rc alias set rustfs http://:9000 @@ -52,9 +52,9 @@ logging: level: info ``` -`force_path_style: true` is required — without it lakeFS builds `lakefs-data.` as a hostname and every request fails with a DNS error. The credentials are supplied through the standard `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables. +`force_path_style: true` erzwingt pfadbasierte Adressierung (Path-Style) und ist erforderlich. Ohne diesen Wert baut lakeFS `lakefs-data.` als Hostnamen, und jede Anfrage scheitert mit einem DNS-Fehler. Die Zugangsdaten kommen über die üblichen Umgebungsvariablen `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY`. -Create the environment file for the service credentials and the initial admin user, replacing the placeholders: +Legen Sie die Umgebungsdatei für die Dienst-Zugangsdaten und den ersten Admin-Benutzer an und ersetzen Sie die Platzhalter: ```ini title=".env" AWS_ACCESS_KEY_ID= @@ -65,7 +65,7 @@ LAKEFS_INSTALLATION_SECRET_ACCESS_KEY= LAKEFS_STATS_ENABLED=false ``` -## 2. Start lakeFS +## 2. lakeFS starten ```bash docker run -d --name lakefs --network oo-rustfs_default \ @@ -75,7 +75,7 @@ docker run -d --name lakefs --network oo-rustfs_default \ treeverse/lakefs:1.58.0 run ``` -Wait for `http://localhost:8000/api/healthcheck` to return `200`, then create a repository with a storage namespace inside the bucket: +Warten Sie, bis `http://localhost:8000/api/healthcheck` `200` zurückgibt, und legen Sie dann ein Repository mit einem Storage-Namespace im Bucket an: ```bash curl -s -u : \ @@ -84,9 +84,9 @@ curl -s -u : \ -d '{"name": "rustfs-demo", "storage_namespace": "s3://lakefs-data/repo"}' ``` -## 3. Commit an object +## 3. Ein Objekt committen -Upload a file to the `main` branch and commit it: +Laden Sie eine Datei auf den Branch `main` hoch und committen Sie sie: ```bash echo "hello from lakefs on rustfs" > hello.txt @@ -101,60 +101,60 @@ curl -s -u : \ -d '{"message": "add hello"}' ``` -Read the object back through the branch ref — the response body is the committed content: +Lesen Sie das Objekt über die Branch-Referenz zurück. Der Antwortkörper ist der committete Inhalt: ```bash curl -s -u : \ "http://localhost:8000/api/v1/repositories/rustfs-demo/refs/main/objects?path=hello.txt" ``` -## 4. Verify objects in RustFS +## 4. Objekte in RustFS prüfen -List the bucket: +Listen Sie den Bucket auf: ```bash rc ls rustfs/lakefs-data/ -r ``` -The output shows the lakeFS metadata objects and the committed data file under the repository prefix: +Die Ausgabe zeigt die Metadatenobjekte von lakeFS und die committete Datendatei unter dem Repository-Präfix: ```text repo/_lakefs/19b2b26e37cb20fc6763c527f88eb5151891b04a2c8c9ddd32870c5c3f353281 repo/data/fueia10jdra000e1c480/daots7ojdra000e1c490 ``` -![lakeFS objects stored in the RustFS Console](./images/rustfs-lakefs-repo.png) +![In der RustFS-Console gespeicherte lakeFS-Objekte](./images/rustfs-lakefs-repo.png) -## 5. Stop or reset the deployment +## 5. Die Bereitstellung stoppen oder zurücksetzen -Stop lakeFS while keeping the data: +Stoppen Sie lakeFS und behalten Sie die Daten: ```bash docker rm -f lakefs ``` -The repository metadata and data stay in the `lakefs-data` bucket, so restarting lakeFS with the same configuration brings the repository back. To delete everything, remove the bucket: +Die Repository-Metadaten und die Daten bleiben im Bucket `lakefs-data`, daher bringt ein Neustart von lakeFS mit derselben Konfiguration das Repository zurück. Um alles zu löschen, entfernen Sie den Bucket: ```bash rc rb rustfs/lakefs-data --force ``` -## Troubleshooting +## Fehlerbehebung -### `failed to create repository: failed to access storage` with a DNS error +### `failed to create repository: failed to access storage` mit einem DNS-Fehler -lakeFS is using virtual-hosted addressing. Set `force_path_style: true` under `blockstore.s3` — in the 1.x configuration schema the older `path_style` key is rejected at startup. +lakeFS verwendet Adressierung im Virtual-Hosted-Stil. Setzen Sie `force_path_style: true` unter `blockstore.s3`. Im Konfigurationsschema 1.x wird der ältere Schlüssel `path_style` beim Start abgelehnt. ### `missing required keys: [auth.encrypt.secret_key]` -lakeFS 1.x requires an encryption key for the local database. Add the `auth.encrypt.secret_key` block as shown in the configuration above. +lakeFS 1.x verlangt einen Verschlüsselungsschlüssel für die lokale Datenbank. Fügen Sie den Block `auth.encrypt.secret_key` wie in der Konfiguration oben hinzu. ### `mkdir /lakefs: permission denied` -The container runs as a non-root user and cannot create the database directory. Run the container with `-u 0` for local testing, or mount a writable directory at the configured path. +Der Container läuft als Benutzer ohne Root-Rechte und kann das Datenbankverzeichnis nicht anlegen. Starten Sie den Container für lokale Tests mit `-u 0`, oder hängen Sie ein beschreibbares Verzeichnis am konfigurierten Pfad ein. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional lakeFS operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [lakeFS S3 blockstore documentation](https://docs.lakefs.io/howto/using-s3.html) to configure the S3 gateway for tools that speak the S3 protocol. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere lakeFS-Operationen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [lakeFS-Dokumentation zum S3-Blockstore](https://docs.lakefs.io/howto/using-s3.html), um das S3-Gateway für Werkzeuge zu konfigurieren, die das S3-Protokoll sprechen. diff --git a/content/de/developer/integration/storage/meta.json b/content/de/developer/integration/storage/meta.json index c6861a9e6..d1fea12ee 100644 --- a/content/de/developer/integration/storage/meta.json +++ b/content/de/developer/integration/storage/meta.json @@ -1,5 +1,5 @@ { - "title": "Storage", + "title": "Speicher", "pages": [ "lakefs", "opendal", diff --git a/content/de/developer/integration/storage/opendal.md b/content/de/developer/integration/storage/opendal.md index 074b7475f..0162b4bf5 100644 --- a/content/de/developer/integration/storage/opendal.md +++ b/content/de/developer/integration/storage/opendal.md @@ -1,13 +1,13 @@ --- title: "OpenDAL" -description: "Access RustFS objects from applications through the Apache OpenDAL data access layer." +description: "Greifen Sie aus Anwendungen über die Datenzugriffsschicht Apache OpenDAL auf RustFS-Objekte zu." --- -This guide connects [Apache OpenDAL](https://github.com/apache/opendal) — the unified data access layer — to **RustFS** through its `s3` service. You will run the OpenDAL Python binding against RustFS, write and read an object, list a prefix, and delete it. The workflow was verified with the `opendal` Python package 0.46 on `python:3.12-slim` and `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [Apache OpenDAL](https://github.com/apache/opendal) — die einheitliche Datenzugriffsschicht — über den Dienst `s3` mit **RustFS**. Sie betreiben das Python-Binding von OpenDAL gegen RustFS, schreiben und lesen ein Objekt, listen ein Präfix auf und löschen es. Der Ablauf wurde mit dem Python-Paket `opendal` 0.46 auf `python:3.12-slim` und `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker and Python 3.9 or later. OpenDAL supports the same `s3` service from Rust, Java, Node.js, and Go bindings with equivalent settings. +Sie benötigen Docker und Python 3.9 oder neuer. OpenDAL unterstützt denselben Dienst `s3` aus den Bindings für Rust, Java, Node.js und Go mit gleichwertigen Einstellungen. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,17 +15,17 @@ flowchart LR OpenDAL -->|"s3 service"| RustFS["RustFS :9000"] ``` -An OpenDAL `Operator` bound to the `s3` service exposes one uniform API — `write`, `read`, `stat`, `list`, `delete` — over the bucket, so the same code runs against S3, RustFS, or any other supported service by changing the connection settings. +Ein OpenDAL-`Operator`, der an den Dienst `s3` gebunden ist, stellt eine einheitliche API bereit — `write`, `read`, `stat`, `list`, `delete` — über den Bucket. Derselbe Code läuft gegen S3, RustFS oder jeden anderen unterstützten Dienst, wenn Sie die Verbindungseinstellungen ändern. -## 1. Set up the project +## 1. Das Projekt einrichten -Install the Python binding: +Installieren Sie das Python-Binding: ```bash pip install opendal ``` -Create the script, replacing all connection placeholders: +Legen Sie das Skript an und ersetzen Sie alle Verbindungsplatzhalter: ```python title="opendal_demo.py" import opendal @@ -47,11 +47,11 @@ op.delete("opendal-demo/hello.txt") print("deleted:", not op.exists("opendal-demo/hello.txt")) ``` -The credential option names are `access_key_id` and `secret_access_key` — the shorter `access_key` names do not exist and fail with a signing error. Path-style addressing is the default for non-AWS endpoints. +Die Namen der Zugangsdatenoptionen sind `access_key_id` und `secret_access_key`. Die kürzeren Namen `access_key` existieren nicht und schlagen mit einem Signaturfehler fehl. Pfadbasierte Adressierung (Path-Style) ist der Standard für Endpunkte außerhalb von AWS. -## 2. Run the demo +## 2. Die Demo ausführen -Run the script from a machine that can reach RustFS: +Führen Sie das Skript von einem Rechner aus, der RustFS erreichen kann: ```bash python opendal_demo.py @@ -64,11 +64,11 @@ listed: opendal-demo/hello.txt deleted: True ``` -The round trip exercises the full object lifecycle: write uploads the bytes, `read` fetches them back, `stat` returns the object size, `list` enumerates the prefix, and `delete` removes the object. +Der Rundlauf übt den vollständigen Objektlebenszyklus: `write` lädt die Bytes hoch, `read` holt sie zurück, `stat` liefert die Objektgröße, `list` zählt das Präfix auf und `delete` entfernt das Objekt. -## 3. Verify objects in RustFS +## 3. Objekte in RustFS prüfen -Comment out the final `op.delete` line, run the script again, and list the prefix in RustFS: +Kommentieren Sie die letzte Zeile `op.delete` aus, führen Sie das Skript erneut aus und listen Sie das Präfix in RustFS auf: ```bash rc ls rustfs/my-bucket/opendal-demo/ -r @@ -79,30 +79,30 @@ hello.txt data/rows.csv ``` -![OpenDAL objects stored in the RustFS Console](./images/rustfs-opendal-objects.png) +![In der RustFS-Console gespeicherte OpenDAL-Objekte](./images/rustfs-opendal-objects.png) -The objects visible in the RustFS Console are exactly the paths the OpenDAL API wrote. +Die in der RustFS-Console sichtbaren Objekte sind genau die Pfade, die die OpenDAL-API geschrieben hat. -## 4. Stop or reset +## 4. Stoppen oder zurücksetzen -OpenDAL is a library and holds no state of its own. To clean up the demo objects: +OpenDAL ist eine Bibliothek und hält keinen eigenen Zustand. So räumen Sie die Demo-Objekte auf: ```bash rc rm rustfs/my-bucket/opendal-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung ### `failed to load signing credential` -The operator received no usable credentials. Use the exact option names `access_key_id` and `secret_access_key`; other spellings are silently ignored and signing then fails. +Der Operator hat keine verwendbaren Zugangsdaten erhalten. Verwenden Sie die exakten Optionsnamen `access_key_id` und `secret_access_key`. Andere Schreibweisen werden stillschweigend ignoriert, und die Signierung schlägt dann fehl. -### Connection or DNS errors on write +### Verbindungs- oder DNS-Fehler beim Schreiben -Confirm the endpoint includes the scheme and port and is reachable from the application. Inside a Compose network the hostname is `rustfs`; from the host use `http://localhost:9000`. +Prüfen Sie, dass der Endpunkt Schema und Port enthält und von der Anwendung aus erreichbar ist. Innerhalb eines Compose-Netzwerks lautet der Hostname `rustfs`. Vom Host aus verwenden Sie `http://localhost:9000`. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional OpenDAL operations. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [OpenDAL documentation](https://opendal.apache.org/docs/) to use the same operator from Rust, Java, or Node.js. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere OpenDAL-Operationen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [OpenDAL-Dokumentation](https://opendal.apache.org/docs/), um denselben Operator aus Rust, Java oder Node.js zu verwenden. diff --git a/content/de/developer/integration/storage/s3fs.md b/content/de/developer/integration/storage/s3fs.md index f1a600d00..4574c0ad1 100644 --- a/content/de/developer/integration/storage/s3fs.md +++ b/content/de/developer/integration/storage/s3fs.md @@ -1,13 +1,13 @@ --- title: "s3fs" -description: "Mount a RustFS bucket as a local filesystem with s3fs-fuse." +description: "Hängen Sie einen RustFS-Bucket mit s3fs-fuse als lokales Dateisystem ein." --- -This guide connects [s3fs-fuse](https://github.com/s3fs-fuse/s3fs-fuse) — the FUSE-based S3 filesystem — to **RustFS**. You will mount a bucket as a local directory, write files through the mount, unmount, and confirm the objects persist in the bucket. The workflow was verified with s3fs v1.93 against `rustfs/rustfs-x86-musl:v2.3.1` on Ubuntu 24.04. +In dieser Anleitung verbinden Sie [s3fs-fuse](https://github.com/s3fs-fuse/s3fs-fuse) — das FUSE-basierte S3-Dateisystem — mit **RustFS**. Sie hängen einen Bucket als lokales Verzeichnis ein, schreiben Dateien über den Mount, hängen ihn aus und bestätigen, dass die Objekte im Bucket erhalten bleiben. Der Ablauf wurde mit s3fs v1.93 gegen `rustfs/rustfs-x86-musl:v2.3.1` auf Ubuntu 24.04 verifiziert. -You need a Linux host with FUSE (`fuse3` package) and the `s3fs` binary. +Sie benötigen einen Linux-Host mit FUSE (Paket `fuse3`) und der Binärdatei `s3fs`. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,9 +15,9 @@ flowchart LR Mount -->|"S3 API"| RustFS["RustFS :9000"] ``` -Every file created under the mount point becomes an object in the bucket, keyed by its relative path — a plain 1:1 mapping with no caching layer. +Jede Datei, die unter dem Mount-Punkt entsteht, wird zu einem Objekt im Bucket, dessen Objektschlüssel der relative Pfad ist. Das ist eine einfache 1:1-Abbildung ohne Cache-Schicht. -## 1. Install +## 1. Installieren ```bash apt-get install -y s3fs @@ -28,16 +28,16 @@ s3fs --version Amazon Simple Storage Service File System V1.93 ... ``` -## 2. Store the credentials +## 2. Die Zugangsdaten speichern -Write the access key and secret key to the password file s3fs expects: +Schreiben Sie Zugriffsschlüssel und geheimen Zugriffsschlüssel in die Passwortdatei, die s3fs erwartet: ```bash echo ":" > ~/.passwd-s3fs chmod 600 ~/.passwd-s3fs ``` -## 3. Mount the bucket +## 3. Den Bucket einhängen ```bash mkdir -p /mnt/s3fs-demo @@ -49,9 +49,9 @@ s3fs s3fs-demo /mnt/s3fs-demo \ -o allow_other -o umask=000 ``` -`use_path_request_style` selects path-style addressing, which is what RustFS serves. `allow_other` lets non-root users read the mount. +`use_path_request_style` wählt pfadbasierte Adressierung (Path-Style), die RustFS bereitstellt. `allow_other` erlaubt Benutzern ohne Root-Rechte, den Mount zu lesen. -## 4. Write and read files +## 4. Dateien schreiben und lesen ```bash echo "hello from s3fs" > /mnt/s3fs-demo/s3fs-test.txt @@ -63,9 +63,9 @@ cat /mnt/s3fs-demo/s3fs-test.txt hello from s3fs ``` -## 5. Verify objects and persistence +## 5. Objekte und Persistenz prüfen -Unmount and remount — the objects persist in the bucket: +Hängen Sie aus und wieder ein. Die Objekte bleiben im Bucket: ```bash fusermount -u /mnt/s3fs-demo @@ -79,7 +79,7 @@ ls /mnt/s3fs-demo/ blob.bin s3fs-test.txt ``` -List the bucket to see the same objects from the S3 side: +Listen Sie den Bucket auf, um dieselben Objekte von der S3-Seite zu sehen: ```bash rc ls rustfs/s3fs-demo/ @@ -90,31 +90,31 @@ rc ls rustfs/s3fs-demo/ [2026-10-06 12:09:26] 16 B s3fs-test.txt ``` -![s3fs files stored in the RustFS Console](./images/rustfs-s3fs-files.png) +![In der RustFS-Console gespeicherte s3fs-Dateien](./images/rustfs-s3fs-files.png) -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen ```bash fusermount -u /mnt/s3fs-demo rc rm rustfs/s3fs-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `fuse: device not found` inside a container +### `fuse: device not found` innerhalb eines Containers -Pass `--device /dev/fuse --cap-add SYS_ADMIN` to `docker run`, or `--privileged` if the mount helper still fails. +Übergeben Sie `--device /dev/fuse --cap-add SYS_ADMIN` an `docker run`, oder `--privileged`, wenn der Mount-Helfer weiterhin scheitert. -### `Permission denied` reading the mount as another user +### `Permission denied` beim Lesen des Mounts als anderer Benutzer -s3fs mounts are private to the mounting user by default. Add `-o allow_other -o umask=000` (or a tighter umask) at mount time. +s3fs-Mounts gehören standardmäßig nur dem Benutzer, der sie eingehängt hat. Fügen Sie beim Einhängen `-o allow_other -o umask=000` (oder eine engere umask) hinzu. -### Mount succeeds but listing is empty on another client +### Der Mount gelingt, die Auflistung ist auf einem anderen Client aber leer -s3fs has no metadata cache shared across mounts, but clients and list operations are eventually consistent. Remount or re-list after a few seconds. +s3fs hat keinen Metadaten-Cache, der über Mounts hinweg geteilt wird, Clients und List-Operationen sind aber letztendlich konsistent. Hängen Sie neu ein oder listen Sie nach einigen Sekunden erneut auf. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional FUSE options. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [s3fs-fuse documentation](https://github.com/s3fs-fuse/s3fs-fuse/wiki/Fuse-Over-https) for performance tuning options such as `-o multipart` and `-o parallel_count`. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere FUSE-Optionen einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [s3fs-fuse-Dokumentation](https://github.com/s3fs-fuse/s3fs-fuse/wiki/Fuse-Over-https) für Leistungsoptionen wie `-o multipart` und `-o parallel_count`. diff --git a/content/de/developer/integration/storage/sftpgo.md b/content/de/developer/integration/storage/sftpgo.md index d37db1408..976686a9f 100644 --- a/content/de/developer/integration/storage/sftpgo.md +++ b/content/de/developer/integration/storage/sftpgo.md @@ -1,13 +1,13 @@ --- title: "SFTPGo" -description: "Serve RustFS buckets over SFTP with SFTPGo." +description: "Stellen Sie RustFS-Buckets über SFTP mit SFTPGo bereit." --- -This guide connects [SFTPGo](https://github.com/drakkan/sftpgo) — the full-featured SFTP/WebDAV/FTP server — to **RustFS** as a per-user S3 backend. You will create an SFTP user whose home directory is a RustFS bucket prefix, upload files over SFTP, and verify the objects in the bucket. The workflow was verified with SFTPGo 2.7.6 against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [SFTPGo](https://github.com/drakkan/sftpgo) — den SFTP-/WebDAV-/FTP-Server — mit **RustFS** als S3-Backend je Benutzer. Sie legen einen SFTP-Benutzer an, dessen Home-Verzeichnis ein Präfix eines RustFS-Buckets ist, laden Dateien über SFTP hoch und prüfen die Objekte im Bucket. Der Ablauf wurde mit SFTPGo 2.7.6 gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker and an SFTP client (`sftp` ships with OpenSSH). +Sie benötigen Docker und einen SFTP-Client (`sftp` gehört zu OpenSSH). -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,9 +15,9 @@ flowchart LR SFTPGo -->|"S3 API"| RustFS["RustFS :9000"] ``` -SFTPGo maps the user's virtual paths onto bucket prefixes. Files uploaded over SFTP become objects under the configured `key_prefix` — nothing is stored on the SFTPGo host itself. +SFTPGo bildet die virtuellen Pfade des Benutzers auf Bucket-Präfixe ab. Über SFTP hochgeladene Dateien werden zu Objekten unter dem konfigurierten `key_prefix`. Auf dem SFTPGo-Host selbst wird nichts gespeichert. -## 1. Run SFTPGo +## 1. SFTPGo starten ```bash docker run -d --name sftpgo --hostname sftpgo --network oo-rustfs_default \ @@ -26,11 +26,11 @@ docker run -d --name sftpgo --hostname sftpgo --network oo-rustfs_default \ drakkan/sftpgo:latest ``` -`SFTPGO_COMMON__TEMP_PATH` matters: for S3 backends SFTPGo streams uploads through a local pipe file, and the default temp path may not exist or be writable. +`SFTPGO_COMMON__TEMP_PATH` ist wichtig: bei S3-Backends streamt SFTPGo Uploads über eine lokale Pipe-Datei, und der Standard-Temporärpfad existiert möglicherweise nicht oder ist nicht beschreibbar. -## 2. Create the admin user +## 2. Den Admin-Benutzer anlegen -The image does not create the admin automatically. Open `http://localhost:8080/web/admin/setup` once and submit the form, or drive it with curl: +Das Image legt den Admin nicht automatisch an. Öffnen Sie einmal `http://localhost:8080/web/admin/setup` und senden Sie das Formular ab, oder steuern Sie es mit curl: ```bash FORM=$(curl -s -c /tmp/sg-cookie.txt http://localhost:8080/web/admin/setup) @@ -47,9 +47,9 @@ curl -s -b /tmp/sg-cookie.txt -X POST http://localhost:8080/web/admin/setup \ setup: 302 ``` -## 3. Create an S3-backed user +## 3. Einen Benutzer mit S3-Backend anlegen -Get an API token and create the user. Three details matter: `home_dir` must be an existing writable directory inside the container (`/tmp` works), `force_path_style` must be `true` for RustFS, and `access_secret` is a KMS object — pass the secret inside `{"status": "Plain", "payload": ...}`: +Holen Sie ein API-Token und legen Sie den Benutzer an. Drei Angaben sind wichtig: `home_dir` muss ein vorhandenes beschreibbares Verzeichnis im Container sein (`/tmp` funktioniert), `force_path_style` muss für RustFS `true` sein, damit pfadbasierte Adressierung (Path-Style) verwendet wird, und `access_secret` ist ein KMS-Objekt. Übergeben Sie das Geheimnis in `{"status": "Plain", "payload": ...}`: ```json title="sftpgo-user.json" { @@ -85,7 +85,7 @@ curl -s -X POST http://localhost:8080/api/v2/users \ create-user: 201 ``` -## 4. Upload and read files over SFTP +## 4. Dateien über SFTP hochladen und lesen ```bash printf "uploaded via sftpgo to rustfs\n" > /tmp/sftp-test.txt @@ -105,7 +105,7 @@ sftp> ls sftp-big.bin sftp-test.txt ``` -## 5. Verify objects in RustFS +## 5. Objekte in RustFS prüfen ```bash rc ls rustfs/sftpgo-demo/home/demo/ -r @@ -118,33 +118,33 @@ rc cat rustfs/sftpgo-demo/home/demo/sftp-test.txt uploaded via sftpgo to rustfs ``` -The object key is the user's virtual path under `key_prefix` — a plain mapping. +Der Objektschlüssel ist der virtuelle Pfad des Benutzers unter `key_prefix`. Das ist eine einfache Abbildung. -![SFTPGo files stored in the RustFS Console](./images/rustfs-sftpgo-home.png) +![In der RustFS-Console gespeicherte SFTPGo-Dateien](./images/rustfs-sftpgo-home.png) -## 6. Stop or reset +## 6. Stoppen oder zurücksetzen ```bash docker rm -f sftpgo rc rm rustfs/sftpgo-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `create resource error` / `InvalidAccessKeyId` on upload +### `create resource error` oder `InvalidAccessKeyId` beim Upload -Check three things in order: `force_path_style` must be `true` (SFTPGo's AWS SDK defaults to virtual-host addressing, which breaks IP endpoints), `access_secret` must use the KMS-object form, and `home_dir` must point at a writable directory (SFTPGo pipes S3 uploads through it). +Prüfen Sie drei Punkte der Reihe nach: `force_path_style` muss `true` sein (das AWS-SDK von SFTPGo verwendet standardmäßig Adressierung im Virtual-Hosted-Stil, die an IP-Endpunkten scheitert), `access_secret` muss die KMS-Objektform verwenden, und `home_dir` muss auf ein beschreibbares Verzeichnis zeigen (SFTPGo leitet S3-Uploads darüber). -### `unknown command init` / admin login rejected +### `unknown command init` oder die Admin-Anmeldung wird abgelehnt -The admin account only exists after the web setup form is submitted once. Repeat step 2; do not reuse an old browser cookie jar. +Das Admin-Konto existiert erst, nachdem das Web-Setup-Formular einmal abgesendet wurde. Wiederholen Sie Schritt 2. Verwenden Sie kein altes Browser-Cookie-Archiv wieder. -### API returns `405 Method Not allowed` for the token +### Die API antwortet mit `405 Method Not allowed` auf das Token -The token endpoint only accepts `GET` with basic auth: `GET /api/v2/token`. +Der Token-Endpunkt akzeptiert nur `GET` mit Basic Auth: `GET /api/v2/token`. -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional SFTPGo backends. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [SFTPGo documentation](https://github.com/drakkan/sftpgo/blob/main/README.md) to add WebDAV/FTP listeners, per-user quotas, and two-factor auth on top of the same bucket. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere SFTPGo-Backends einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie der [SFTPGo-Dokumentation](https://github.com/drakkan/sftpgo/blob/main/README.md), um WebDAV- und FTP-Listener, Kontingente je Benutzer und Zwei-Faktor-Authentifizierung auf demselben Bucket hinzuzufügen. diff --git a/content/de/developer/integration/storage/zerofs.md b/content/de/developer/integration/storage/zerofs.md index 2dd1640b6..7a3203e00 100644 --- a/content/de/developer/integration/storage/zerofs.md +++ b/content/de/developer/integration/storage/zerofs.md @@ -1,13 +1,13 @@ --- title: "ZeroFS" -description: "Serve a RustFS bucket as a POSIX filesystem over NFS with ZeroFS." +description: "Stellen Sie einen RustFS-Bucket mit ZeroFS als POSIX-Dateisystem über NFS bereit." --- -This guide connects [ZeroFS](https://github.com/Barre/ZeroFS) — the log-structured filesystem that serves S3 buckets as POSIX filesystems — to **RustFS** as its object storage backend. You will run ZeroFS with its LSM tree rooted in a RustFS bucket, mount the filesystem over NFS on a Linux host, write files through the mount, and verify they survive a ZeroFS restart as objects in the bucket. The workflow was verified with ZeroFS v2.3.5 (ghcr.io/barre/zerofs) against `rustfs/rustfs-x86-musl:v2.3.1`. +In dieser Anleitung verbinden Sie [ZeroFS](https://github.com/Barre/ZeroFS) — das log-strukturierte Dateisystem, das S3-Buckets als POSIX-Dateisysteme bereitstellt — mit **RustFS** als Objektspeicher-Backend. Sie betreiben ZeroFS mit seinem LSM-Baum, dessen Wurzel in einem RustFS-Bucket liegt, hängen das Dateisystem über NFS auf einem Linux-Host ein, schreiben Dateien über den Mount und prüfen, dass sie einen Neustart von ZeroFS als Objekte im Bucket überstehen. Der Ablauf wurde mit ZeroFS v2.3.5 (ghcr.io/barre/zerofs) gegen `rustfs/rustfs-x86-musl:v2.3.1` verifiziert. -You need Docker and a Linux host with an NFS client (`nfs-common`). This deployment is intended for local integration testing, not production. +Sie benötigen Docker und einen Linux-Host mit NFS-Client (`nfs-common`). Diese Bereitstellung ist für lokale Integrationstests gedacht, nicht für den Produktivbetrieb. -## Architecture +## Architektur ```mermaid flowchart LR @@ -15,11 +15,11 @@ flowchart LR ZeroFS -->|"LSM SSTs, WAL, manifests"| RustFS["RustFS :9000"] ``` -ZeroFS translates filesystem operations into an LSM key-value tree stored in the bucket: writes land in a write-ahead log, flush into SST segments, and compaction runs in the background. Clients see an ordinary directory tree over NFS (or 9P/NBD). +ZeroFS übersetzt Dateisystemoperationen in einen LSM-Schlüssel-Wert-Baum, der im Bucket liegt: Schreibvorgänge landen in einem Write-Ahead-Log, werden in SST-Segmente geleert, und die Compaction läuft im Hintergrund. Clients sehen einen gewöhnlichen Verzeichnisbaum über NFS (oder 9P/NBD). -## 1. Generate the configuration +## 1. Die Konfiguration erzeugen -Create the bucket and the config file, replacing all connection placeholders: +Legen Sie den Bucket und die Konfigurationsdatei an und ersetzen Sie alle Verbindungsplatzhalter: ```bash rc mb rustfs/zerofs-demo @@ -28,7 +28,7 @@ docker run --rm -u root:root -v /opt/zerofs:/cfg -w /cfg \ --entrypoint /bin/sh ghcr.io/barre/zerofs:latest -c "zerofs init" ``` -Then edit `zerofs.toml` so the storage and AWS sections point at RustFS: +Bearbeiten Sie danach `zerofs.toml`, sodass die Abschnitte für Speicher und AWS auf RustFS zeigen: ```toml title="zerofs.toml" [cache] @@ -53,11 +53,11 @@ default_region = "us-east-1" allow_http = "true" ``` -The `endpoint` plus `allow_http` pair is what redirects ZeroFS from AWS to RustFS. Custom endpoints use path-style addressing, so no extra option is needed. +Das Paar `endpoint` und `allow_http` lenkt ZeroFS von AWS auf RustFS um. Eigene Endpunkte verwenden pfadbasierte Adressierung (Path-Style), daher ist keine weitere Option nötig. -## 2. Run ZeroFS +## 2. ZeroFS starten -Run the server with the config file, credentials, and a writable cache directory (the image runs as UID 1001): +Starten Sie den Server mit der Konfigurationsdatei, den Zugangsdaten und einem beschreibbaren Cache-Verzeichnis (das Image läuft als UID 1001): ```bash mkdir -p /opt/zerofs/cache && chown -R 1001:1001 /opt/zerofs/cache @@ -75,9 +75,9 @@ docker run -d --name zerofs --network oo-rustfs_default -p 2049:2049 \ INFO zerofs::nfs: NFS server listening on 0.0.0.0:2049 ``` -## 3. Mount over NFS +## 3. Über NFS einhängen -On the host, mount the export with the options ZeroFS recommends: +Hängen Sie den Export auf dem Host mit den Optionen ein, die ZeroFS empfiehlt: ```bash apt-get install -y nfs-common @@ -87,16 +87,16 @@ mount -t nfs -o async,nolock,rsize=1048576,wsize=1048576,tcp,port=2049,mountport 127.0.0.1:/ /mnt/zerofs ``` -The mount is an ordinary POSIX filesystem: +Der Mount ist ein gewöhnliches POSIX-Dateisystem: ```bash echo "written via zerofs nfs mount on rustfs" > /mnt/zerofs/hello.txt dd if=/dev/urandom of=/mnt/zerofs/data/inner/blob.bin bs=1M count=8 ``` -## 4. Verify persistence and objects in RustFS +## 4. Persistenz und Objekte in RustFS prüfen -Force pending writes to the bucket, then restart ZeroFS and remount: +Schreiben Sie ausstehende Schreibvorgänge in den Bucket, starten Sie ZeroFS neu und hängen Sie erneut ein: ```bash docker exec zerofs zerofs flush -c /zerofs.toml @@ -106,7 +106,7 @@ mount -t nfs -o async,nolock,rsize=1048576,wsize=1048576,tcp,port=2049,mountport 127.0.0.1:/ /mnt/zerofs ``` -Everything written before the restart is still there: +Alles, was vor dem Neustart geschrieben wurde, ist noch da: ```bash cat /mnt/zerofs/hello.txt @@ -118,7 +118,7 @@ written via zerofs nfs mount on rustfs 645faaefe499f9ebda8edceeeb1a6261999aece7 /mnt/zerofs/data/inner/blob.bin ``` -List the bucket to see where the files actually live: +Listen Sie den Bucket auf, um zu sehen, wo die Dateien tatsächlich liegen: ```bash rc ls rustfs/zerofs-demo/ -r | head -4 @@ -130,45 +130,45 @@ zerofs-data/manifest/0000000000000000.json zerofs-data/wal/00000000000000000001.sst ``` -Files are not stored 1:1 — they are keys and values inside the LSM tree, which is what lets ZeroFS serve a bucket as a filesystem. +Dateien werden nicht 1:1 gespeichert. Sie sind Schlüssel und Werte im LSM-Baum, und genau das erlaubt ZeroFS, einen Bucket als Dateisystem bereitzustellen. -![ZeroFS LSM data stored in the RustFS Console](./images/rustfs-zerofs-data.png) +![In der RustFS-Console gespeicherte ZeroFS-LSM-Daten](./images/rustfs-zerofs-data.png) -## 5. Stop or reset +## 5. Stoppen oder zurücksetzen -To tear down the demo while keeping the bucket objects: +Um die Demo abzubauen und die Bucket-Objekte zu behalten: ```bash umount /mnt/zerofs docker rm -f zerofs ``` -To delete the stored data (this erases the filesystem itself): +Um die gespeicherten Daten zu löschen (damit löschen Sie das Dateisystem selbst): ```bash rc rm rustfs/zerofs-demo/ --recursive --force ``` -## Troubleshooting +## Fehlerbehebung -### `Failed to parse config file: missing field uid` at `[servers.webui]` +### `Failed to parse config file: missing field uid` bei `[servers.webui]` -ZeroFS v2.3.5 requires `uid` and `gid` in the `[servers.webui]` section when it is present. Either add `uid = 1000` and `gid = 1000` or delete the section entirely if you do not need the Web UI. +ZeroFS v2.3.5 verlangt `uid` und `gid` im Abschnitt `[servers.webui]`, wenn er vorhanden ist. Fügen Sie entweder `uid = 1000` und `gid = 1000` hinzu oder löschen Sie den Abschnitt, wenn Sie die Weboberfläche nicht brauchen. -### `Permission denied` creating the cache directory +### `Permission denied` beim Anlegen des Cache-Verzeichnisses -The container runs as UID 1001. After mounting the cache volume, run `chown -R 1001:1001 ` before starting the container. +Der Container läuft als UID 1001. Führen Sie nach dem Einhängen des Cache-Volumes `chown -R 1001:1001 ` aus, bevor Sie den Container starten. -### Mount fails or hangs +### Der Mount scheitert oder hängt -Confirm the NFS client package is installed (`nfs-common`) and that ZeroFS is listening on `0.0.0.0:2049` inside a network your client can reach. The `port=2049,mountport=2049` options matter because ZeroFS serves the mountd traffic on the same port. +Prüfen Sie, dass das NFS-Client-Paket installiert ist (`nfs-common`) und dass ZeroFS auf `0.0.0.0:2049` in einem Netzwerk lauscht, das Ihr Client erreichen kann. Die Optionen `port=2049,mountport=2049` sind wichtig, weil ZeroFS den mountd-Verkehr auf demselben Port bereitstellt. -### Writes vanish after a container crash +### Schreibvorgänge verschwinden nach einem Container-Absturz -ZeroFS buffers writes and flushes periodically. For the demo, run `docker exec zerofs zerofs flush -c /zerofs.toml`; in production, clients that need strict durability should fsync (or use the 9P mount, whose fsync waits for stable storage). +ZeroFS puffert Schreibvorgänge und leert sie periodisch. Führen Sie für die Demo `docker exec zerofs zerofs flush -c /zerofs.toml` aus. In der Produktion sollten Clients, die strenge Dauerhaftigkeit brauchen, fsync verwenden (oder den 9P-Mount, dessen fsync auf stabilen Speicher wartet). -## Next steps +## Nächste Schritte -- Review [S3 compatibility notes](/administration/protocols/s3) before adopting additional ZeroFS backends. -- Create dedicated production credentials with [Access Key Management](/security-compliance/iam/access-token). -- Follow the [ZeroFS configuration guide](https://www.zerofs.net/configuration) for cache sizing, 9P/NBD serving, and high-availability replication over the same bucket. +- Lesen Sie die [S3-Kompatibilitätshinweise](/de/administration/protocols/s3), bevor Sie weitere ZeroFS-Backends einsetzen. +- Erstellen Sie dedizierte Produktions-Zugangsdaten über die [Zugriffsschlüssel-Verwaltung](/de/security-compliance/iam/access-token). +- Folgen Sie dem [ZeroFS-Konfigurationsleitfaden](https://www.zerofs.net/configuration) für Cache-Größe, 9P-/NBD-Bereitstellung und Hochverfügbarkeits-Replikation über denselben Bucket. diff --git a/content/de/developer/license.md b/content/de/developer/license.md index f2910342b..9311f12b9 100644 --- a/content/de/developer/license.md +++ b/content/de/developer/license.md @@ -1,14 +1,14 @@ --- -title: RustFS Open Source License -description: RustFS is released under the Apache 2.0 license. +title: Open-Source-Lizenz von RustFS +description: RustFS wird unter der Apache-2.0-Lizenz veröffentlicht. --- -## Open Source License +## Open-Source-Lizenz -- RustFS is released under the Apache 2.0 license. +- RustFS wird unter der Apache-2.0-Lizenz veröffentlicht. - [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) -## License Terms +## Lizenzbedingungen _Version 2.0, January 2004_ http://www.apache.org/licenses/ diff --git a/content/de/developer/mcp.md b/content/de/developer/mcp.md index fd997b019..85b5bd0ec 100644 --- a/content/de/developer/mcp.md +++ b/content/de/developer/mcp.md @@ -1,38 +1,38 @@ --- title: "RustFS MCP" -description: "RustFS MCP Usage Guide" +description: "Verbinden Sie KI-Assistenten über den RustFS-MCP-Server mit dem RustFS-Objektspeicher." --- -**RustFS MCP Server** is a high-performance [Model Context Protocol (MCP)](https://www.anthropic.com/news/model-context-protocol) server that provides AI/LLM tools with seamless access to S3-compatible object storage operations. Built with Rust for performance and security, it enables AI assistants like Claude Desktop to interact with cloud storage through standardized protocols. +Der **RustFS MCP Server** ist ein [Model Context Protocol (MCP)](https://www.anthropic.com/news/model-context-protocol)-Server, der KI-Assistenten wie Claude Desktop Zugriff auf S3-kompatiblen Objektspeicher gibt. -### What is MCP? +### Was ist MCP? -The Model Context Protocol is an open standard that enables AI applications to establish secure, controlled connections with external systems. This server acts as a bridge between AI tools and S3-compatible storage services, providing structured access to file operations while maintaining security and observability. +Das Model Context Protocol ist ein offener Standard, mit dem KI-Anwendungen sichere, kontrollierte Verbindungen zu externen Systemen aufbauen. Dieser Server verbindet KI-Werkzeuge mit S3-kompatiblen Speicherdiensten. Er bietet strukturierten Zugriff auf Objektoperationen und wahrt dabei Sicherheit und Observability. -## ✨ Features +## Funktionen -### Supported S3 Operations +### Unterstützte S3-Operationen -- **List Buckets**: Lists all accessible S3 buckets. -- **List Objects**: Browses bucket contents with optional prefix filtering. -- **Upload Files**: Uploads local files with automatic MIME type detection and cache control. -- **Get Objects**: Retrieves objects from S3 storage, supporting read or download modes. +- **Buckets auflisten**: Listet alle zugänglichen S3-Buckets auf. +- **Objekte auflisten**: Durchsucht den Inhalt eines Buckets, optional mit Präfixfilter. +- **Dateien hochladen**: Lädt lokale Dateien hoch, erkennt den MIME-Typ automatisch und setzt Cache-Control. +- **Objekte abrufen**: Ruft Objekte aus dem S3-Speicher ab und unterstützt die Modi Lesen und Herunterladen. -## 🔧 Installation +## Installation -:::warning[Build instructions may be outdated] +:::warning[Anweisungen zum Bauen können veraltet sein] -The `rustfs-mcp` crate is no longer part of the current `rustfs/rustfs` main branch, so the build commands below may fail against a fresh clone. Check the [RustFS GitHub organization](https://github.com/rustfs) for the MCP server's current location before building from source. +Das Crate `rustfs-mcp` gehört nicht mehr zum aktuellen `main`-Branch von `rustfs/rustfs`. Die folgenden Build-Befehle können daher bei einem frisch geklonten Repository fehlschlagen. Prüfen Sie vor dem Bauen aus dem Quellcode in der [RustFS-Organisation auf GitHub](https://github.com/rustfs), wo der MCP-Server derzeit liegt. ::: -### Prerequisites +### Voraussetzungen -- Rust 1.75+ (for building from source) -- Configured AWS credentials (via environment variables, AWS CLI, or IAM roles) -- Access to S3-compatible storage services +- Rust 1.75 oder höher (zum Bauen aus dem Quellcode) +- Konfigurierte AWS-Zugangsdaten (über Umgebungsvariablen, die AWS CLI oder IAM-Rollen) +- Zugriff auf S3-kompatible Speicherdienste -### Building from Source +### Aus dem Quellcode bauen ```bash # Clone the repository @@ -46,9 +46,9 @@ cargo build --release -p rustfs-mcp ./target/release/rustfs-mcp ``` -## ⚙️ Configuration +## Konfiguration -### Environment Variables +### Umgebungsvariablen ```bash # AWS credentials (required) @@ -63,23 +63,23 @@ export AWS_ENDPOINT_URL=http://localhost:9000 export RUST_LOG=info ``` -### Command Line Options +### Befehlszeilenoptionen ```bash rustfs-mcp --help ``` -The server supports various command line options to customize behavior: +Der Server unterstützt mehrere Befehlszeilenoptionen, mit denen Sie das Verhalten anpassen: -- `--access-key-id`: AWS access key ID for S3 authentication -- `--secret-access-key`: AWS secret key for S3 authentication -- `--region`: AWS region for S3 operations (default: us-east-1) -- `--endpoint-url`: Custom S3 endpoint URL (for MinIO, LocalStack, etc.) -- `--log-level`: Log level configuration (default: rustfs_mcp_server=info) +- `--access-key-id`: AWS-Zugriffsschlüssel-ID für die S3-Authentifizierung +- `--secret-access-key`: geheimer AWS-Zugriffsschlüssel für die S3-Authentifizierung +- `--region`: AWS-Region für S3-Operationen (Standard: us-east-1) +- `--endpoint-url`: benutzerdefinierte S3-Endpunkt-URL (für MinIO, LocalStack und andere) +- `--log-level`: Log-Level (Standard: rustfs_mcp_server=info) -## 🚀 Usage +## Verwendung -### Starting the Server +### Server starten ```bash # Start the MCP server @@ -89,9 +89,9 @@ rustfs-mcp rustfs-mcp --log-level debug --region us-west-2 ``` -### Integration with Chat Clients +### Integration mit Chat-Clients -#### Option 1: Using Command Line Arguments +#### Option 1: Befehlszeilenargumente ```json { @@ -109,7 +109,7 @@ rustfs-mcp --log-level debug --region us-west-2 } ``` -#### Option 2: Using Environment Variables +#### Option 2: Umgebungsvariablen ```json { @@ -126,9 +126,9 @@ rustfs-mcp --log-level debug --region us-west-2 } ``` -### Using with Docker +### Verwendung mit Docker -[RustFS MCP officially provides a Dockerfile](https://github.com/rustfs/rustfs/tree/main/crates/mcp) that can be used to build container images for using RustFS MCP. +RustFS MCP stellt ein [offizielles Dockerfile](https://github.com/rustfs/rustfs/tree/main/crates/mcp) bereit, mit dem Sie ein Container-Image bauen. ```bash # Clone RustFS repository code @@ -138,11 +138,11 @@ git clone https://github.com/rustfs/rustfs.git docker build -f crates/mcp/Dockerfile -t rustfs/rustfs-mcp . ``` -After successful build, you can configure it in the MCP configuration of AI IDEs. +Wenn das Image gebaut wurde, fügen Sie den Server der MCP-Konfiguration Ihrer IDE hinzu. -#### Configuring MCP in AI IDEs +#### MCP in KI-IDEs konfigurieren -Currently, mainstream AI IDEs such as Cursor, Windsurf, Trae, etc. all support MCP. For example, in Trae, add the following content to the MCP configuration (**MCP --> Add**): +Viele KI-IDEs, darunter Cursor, Windsurf und Trae, unterstützen MCP. Fügen Sie in Trae beispielsweise den folgenden Inhalt zur MCP-Konfiguration hinzu (**MCP --> Add**): ```json { @@ -174,88 +174,88 @@ Currently, mainstream AI IDEs such as Cursor, Windsurf, Trae, etc. all support M } ``` -> `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` are RustFS access keys. You can refer to the [Access Key Management chapter](../security-compliance/iam/access-token.md) for creation. +> `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY` sind RustFS-Zugriffsschlüssel. Zum Anlegen siehe [Zugriffsschlüssel-Verwaltung](../security-compliance/iam/access-token.md). -If added successfully, you can list the [available tools](#️-available-tools) on the MCP configuration page. +Wenn der Server erfolgreich hinzugefügt wurde, listet die MCP-Konfigurationsseite seine [verfügbaren Tools](#verfügbare-tools) auf. -![add rustfs mcp in trae mcp configuration successfully](images/add-rustfs-mcp-succ.png) +![RustFS-MCP-Server in der MCP-Konfiguration von Trae hinzugefügt](images/add-rustfs-mcp-succ.png) -In Trae, you can use the corresponding tools by entering the corresponding prompts. For example, in Trae's chat dialog, enter: +Um in Trae ein MCP-Tool aufzurufen, geben Sie im Chat eine Eingabeaufforderung ein. Zum Beispiel: ```text Please help me list the buckets in the current rustfs instance, thank you! ``` -Returns the following response: +Trae gibt die folgende Antwort zurück: -![list rustfs bucket with rustfs mcp](images/list-rustfs-bucket-with-mcp.png) +![Buckets einer RustFS-Instanz, aufgelistet mit dem RustFS-MCP](images/list-rustfs-bucket-with-mcp.png) -Trae uses **Builder with MCP** mode, calling the `list_buckets` tool to list all buckets in the configured RustFS instance. The same applies to calls to other tools. +Trae verwendet den Modus **Builder with MCP** und ruft das Tool `list_buckets` auf, um alle Buckets in der konfigurierten RustFS-Instanz aufzulisten. Andere Tools funktionieren auf dieselbe Weise. -## 🛠️ Available Tools +## Verfügbare Tools -The MCP server exposes the following tools that AI assistants can use: +Der MCP-Server stellt die folgenden Tools bereit, die KI-Assistenten verwenden können: ### `list_buckets` -Lists all S3 buckets accessible with the configured credentials. +Listet alle S3-Buckets auf, die mit den konfigurierten Zugangsdaten erreichbar sind. -**Parameters**: None +**Parameter**: Keine ### `list_objects` -Lists objects in an S3 bucket with optional prefix filtering. +Listet Objekte in einem S3-Bucket auf, optional mit Präfixfilter. -**Parameters**: +**Parameter**: -- `bucket_name` (string): Name of the S3 bucket -- `prefix` (string, optional): Prefix for filtering objects +- `bucket_name` (string): Name des S3-Buckets +- `prefix` (string, optional): Präfix zum Filtern der Objekte ### `upload_file` -Uploads a local file to S3 with automatic MIME type detection. +Lädt eine lokale Datei nach S3 hoch und erkennt den MIME-Typ automatisch. -**Parameters**: +**Parameter**: -- `local_file_path` (string): Local file path -- `bucket_name` (string): Target S3 bucket -- `object_key` (string): S3 object key (target path) -- `content_type` (string, optional): Content type (auto-detected if not provided) -- `storage_class` (string, optional): S3 storage class -- `cache_control` (string, optional): Cache control header +- `local_file_path` (string): lokaler Dateipfad +- `bucket_name` (string): Ziel-S3-Bucket +- `object_key` (string): S3-Objektschlüssel (Zielpfad) +- `content_type` (string, optional): Inhaltstyp (wird automatisch erkannt, wenn er fehlt) +- `storage_class` (string, optional): S3-Speicherklasse +- `cache_control` (string, optional): Cache-Control-Header ### `get_object` -Retrieves objects from S3 with two operation modes: direct content reading or download to file. +Ruft Objekte aus S3 in zwei Betriebsmodi ab: Inhalt direkt lesen oder in eine Datei herunterladen. -**Parameters**: +**Parameter**: -- `bucket_name` (string): Source S3 bucket -- `object_key` (string): S3 object key -- `version_id` (string, optional): Version ID for versioned objects -- `mode` (string, optional): Operation mode - "read" (default) returns content directly, "download" saves to local file -- `local_path` (string, optional): Local file path (required when mode is "download") -- `max_content_size` (number, optional): Maximum content size for read mode in bytes (default: 1MB) +- `bucket_name` (string): Quell-S3-Bucket +- `object_key` (string): S3-Objektschlüssel +- `version_id` (string, optional): Versions-ID für versionierte Objekte +- `mode` (string, optional): Betriebsmodus. `read` (Standard) gibt den Inhalt direkt zurück, `download` speichert in eine lokale Datei +- `local_path` (string, optional): lokaler Dateipfad (erforderlich, wenn `mode` den Wert `download` hat) +- `max_content_size` (number, optional): maximale Inhaltsgröße im Lesemodus in Byte (Standard: 1 MB) ### `create_bucket` -Creates a new RustFS bucket. +Erstellt einen neuen RustFS-Bucket. -**Parameters**: +**Parameter**: -- `bucket_name` (string): Name of the bucket to create. +- `bucket_name` (string): Name des zu erstellenden Buckets. ### `delete_bucket` -Deletes the specified RustFS bucket. +Löscht den angegebenen RustFS-Bucket. -**Parameters**: +**Parameter**: -- `bucket_name` (string): Name of the bucket to delete. +- `bucket_name` (string): Name des zu löschenden Buckets. -## Architecture +## Architektur -The MCP server is built with a modular architecture: +Der MCP-Server ist modular aufgebaut: ```text rustfs-mcp/ diff --git a/content/de/developer/sdk/go.md b/content/de/developer/sdk/go.md index b40cab279..2b1d695c5 100644 --- a/content/de/developer/sdk/go.md +++ b/content/de/developer/sdk/go.md @@ -1,23 +1,23 @@ --- -title: "Golang SDK Guide" -description: "Use the AWS SDK for Go v2 to operate on RustFS instances, including creating and deleting buckets and objects." +title: "Go-SDK-Anleitung" +description: "Führen Sie mit dem AWS SDK für Go v2 Operationen auf RustFS-Instanzen aus, einschließlich des Erstellens und Löschens von Buckets und Objekten." --- -RustFS ships no first-party Go SDK — it is fully S3-compatible, so you use the official AWS SDK for Go v2 configured to point at your RustFS server. Through the SDK, you can operate on RustFS, including creating and deleting buckets/objects, uploading and downloading files, etc. +RustFS enthält kein eigenes Go-SDK. Der Dienst ist S3-kompatibel, daher verwenden Sie das offizielle AWS SDK für Go v2 und richten es auf Ihren RustFS-Server aus. Mit dem SDK erstellen und löschen Sie Buckets und laden Objekte hoch, herunter und löschen sie. -## Prerequisites +## Voraussetzungen -- Go 1.21 or later -- A working RustFS instance (refer to [Installation Guide](../../installation/index.md)) — the S3 API listens on port `9000`, the Console on port `9001` -- Access keys, set at install time via the `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` environment variables (refer to [Access Key Management](../../security-compliance/iam/access-token.md)) +- Go 1.21 oder höher +- Eine funktionsfähige RustFS-Instanz (siehe [Installationsanleitung](../../installation/index.md)). Die S3-API nimmt Verbindungen auf Port `9000` entgegen, die Console (Weboberfläche) auf Port `9001` +- Zugriffsschlüssel, die Sie bei der Installation über die Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` setzen (siehe [Zugriffsschlüssel-Verwaltung](../../security-compliance/iam/access-token.md)) -:::tip[Local test] +:::tip[Lokaler Test] -If you did not set credentials at install time, the server defaults to `rustfsadmin` / `rustfsadmin` — fine for a throwaway local trial, never for anything reachable by others. +Wenn Sie bei der Installation keine Anmeldedaten gesetzt haben, verwendet der Server standardmäßig `rustfsadmin` / `rustfsadmin`. Das reicht für einen wegwerfbaren lokalen Test, niemals für eine Instanz, die andere erreichen können. ::: -Install the SDK modules: +Installieren Sie die SDK-Module: ```bash go mod init rustfs-go-demo @@ -26,9 +26,9 @@ go get github.com/aws/aws-sdk-go-v2/credentials go get github.com/aws/aws-sdk-go-v2/service/s3 ``` -## Initializing the Client +## Client initialisieren -The following is a complete, runnable program. It reads its configuration from environment variables and initializes the client from an `aws.Config`: +Das folgende Programm ist vollständig und ausführbar. Es liest seine Konfiguration aus Umgebungsvariablen und initialisiert den Client aus einer `aws.Config`: ```go title="main.go" package main @@ -83,11 +83,11 @@ func main() { :::note -These environment variable names (`RUSTFS_ENDPOINT_URL`, `RUSTFS_REGION`, `RUSTFS_ACCESS_KEY_ID`, `RUSTFS_SECRET_ACCESS_KEY`) are just this example's client-side conventions — they are read by your Go program, not by RustFS. They are distinct from the server-side `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` variables used when installing RustFS. +Diese Namen von Umgebungsvariablen (`RUSTFS_ENDPOINT_URL`, `RUSTFS_REGION`, `RUSTFS_ACCESS_KEY_ID`, `RUSTFS_SECRET_ACCESS_KEY`) sind nur Konventionen auf der Client-Seite dieses Beispiels. Ihr Go-Programm liest sie, nicht RustFS. Sie unterscheiden sich von den serverseitigen Variablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY`, die bei der Installation von RustFS verwendet werden. ::: -Run it (replace `localhost` with your server's IP address if RustFS runs on another machine): +Führen Sie das Programm aus (ersetzen Sie `localhost` durch die IP-Adresse Ihres Servers, wenn RustFS auf einem anderen Rechner läuft): ```bash export RUSTFS_ENDPOINT_URL="http://localhost:9000" @@ -102,9 +102,9 @@ Buckets: - my-bucket ``` -You can now perform bucket and object operations. The snippets below run inside the `main` function above, reusing `client` and `ctx`. +Sie können nun Bucket- und Objektoperationen ausführen. Die folgenden Ausschnitte laufen in der Funktion `main` oben und verwenden `client` und `ctx` weiter. -## Create Bucket +## Bucket erstellen ```go _, err = client.CreateBucket(ctx, &s3.CreateBucketInput{ @@ -120,7 +120,7 @@ fmt.Println("bucket created") bucket created ``` -## List Buckets +## Buckets auflisten ```go resp, err := client.ListBuckets(ctx, &s3.ListBucketsInput{}) @@ -139,7 +139,7 @@ Buckets: - my-bucket ``` -## Delete Bucket +## Bucket löschen ```go _, err = client.DeleteBucket(ctx, &s3.DeleteBucketInput{ @@ -155,7 +155,7 @@ fmt.Println("bucket deleted") bucket deleted ``` -## List Objects +## Objekte auflisten ```go resp, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{ @@ -173,9 +173,9 @@ for _, obj := range resp.Contents { - hello.txt ``` -## Upload Object +## Objekt hochladen -Uploading a string body (add `"strings"` to your imports): +Einen String-Body hochladen (fügen Sie `"strings"` zu Ihren Imports hinzu): ```go _, err = client.PutObject(ctx, &s3.PutObjectInput{ @@ -193,9 +193,9 @@ fmt.Println("object uploaded") object uploaded ``` -## Download Object +## Objekt herunterladen -Reading the object body (add `"io"` to your imports): +Den Objekt-Body lesen (fügen Sie `"io"` zu Ihren Imports hinzu): ```go resp, err := client.GetObject(ctx, &s3.GetObjectInput{ @@ -219,4 +219,4 @@ fmt.Println("content is :", string(data)) content is : hello rustfs ``` -For other operations (presigned URLs, multipart uploads, and more), see the [AWS SDK for Go v2 documentation](https://aws.github.io/aws-sdk-go-v2/docs/) — every S3-compatible call works against RustFS the same way. +Weitere Operationen (vorsignierte URLs, mehrteilige Uploads und mehr) stehen in der [Dokumentation zum AWS SDK für Go v2](https://aws.github.io/aws-sdk-go-v2/docs/). Die meisten S3-Operationen funktionieren gegenüber RustFS auf dieselbe Weise. Ausnahmen stehen unter [S3-Kompatibilität](/de/reference/s3-compatibility). diff --git a/content/de/developer/sdk/index.md b/content/de/developer/sdk/index.md index f57b4164b..37d9e257f 100644 --- a/content/de/developer/sdk/index.md +++ b/content/de/developer/sdk/index.md @@ -1,43 +1,41 @@ --- -title: "RustFS SDK Overview" -description: "Overview of supported S3 SDKs for RustFS." +title: "SDKs" +description: "Überblick über die unterstützten S3-SDKs für RustFS." --- -RustFS is a distributed object storage system fully compatible with the S3 protocol. Users can: +RustFS ist ein verteiltes Objektspeichersystem mit einer S3-kompatiblen API. Sie können: -- Manage RustFS through the Console management interface. -- Manage RustFS through S3 clients. -- Implement object storage operations and management on the business side through SDKs. +- RustFS in der Console (Weboberfläche) verwalten. +- RustFS über S3-Clients verwalten. +- Buckets und Objekte aus Ihrer Anwendung mit einem S3-SDK verwalten. -Currently, the SDKs provided by RustFS include: +Die folgenden Anleitungen erklären, wie Sie S3-SDKs mit RustFS verwenden: -- [Java SDK](./java.md) -- [JavaScript SDK](./javascript.md) -- [Python SDK](./python.md) -- [Rust SDK](./rust.md) -- [TypeScript SDK](./typescript.md) -- [Golang SDK](./go.md) +- [Java-SDK](./java.md) +- [JavaScript-SDK](./javascript.md) +- [Python-SDK](./python.md) +- [Rust-SDK](./rust.md) +- [TypeScript-SDK](./typescript.md) +- [Go-SDK](./go.md) -## Terminology +## Terminologie -Amazon S3 (Simple Storage Service) was the first widely adopted object storage service. Its API has become the de facto standard for object storage. In this documentation, "S3" refers to the protocol. +Amazon Simple Storage Service (Amazon S3) war der erste weit verbreitete Objektspeicherdienst. Seine API ist zum De-facto-Standard für Objektspeicher geworden. In dieser Dokumentation bezeichnet „S3“ das Protokoll. -## SDK Recommendations +## SDK-Empfehlungen -We recommend using the official AWS S3 SDKs. These SDKs are mature, well-maintained, and highly optimized. +Wir empfehlen die offiziellen AWS-S3-SDKs. Diese SDKs sind ausgereift, werden gepflegt und sind stark optimiert. -If you have a familiar and trusted SDK from a vendor, you can use it. +Sie können auch ein Hersteller-SDK verwenden, das Sie kennen und dem Sie vertrauen, sofern es die benötigten S3-Operationen unterstützt. -Some third-party SDKs may have non-standard implementations. We recommend avoiding SDKs that are not strictly S3-compliant. +Einige SDKs von Drittanbietern können vom Standard abweichen. Wir empfehlen, SDKs zu vermeiden, die nicht streng S3-konform sind. -## Compatibility with MinIO SDKs +## Kompatibilität mit MinIO-SDKs -Yes, RustFS is fully compatible with MinIO SDKs. +RustFS funktioniert mit den MinIO-SDKs. -If you are using MinIO SDKs, you can modify the Endpoint, AK, and SK to be directly compatible with RustFS. +Um ein MinIO-SDK mit RustFS zu verbinden, setzen Sie den Endpunkt, den Zugriffsschlüssel und den geheimen Zugriffsschlüssel auf Ihre RustFS-Werte. -## Handling Incompatible SDKs +## Nicht kompatible SDKs -If you encounter an SDK that does not support standard S3, MinIO, or RustFS: - -We recommend switching to a standard AWS S3 SDK. +Wenn ein SDK nicht mit Standard-S3, MinIO oder RustFS funktioniert, empfehlen wir den Wechsel zu einem offiziellen AWS-SDK für S3. diff --git a/content/de/developer/sdk/java.md b/content/de/developer/sdk/java.md index 938a7f166..878955bab 100644 --- a/content/de/developer/sdk/java.md +++ b/content/de/developer/sdk/java.md @@ -1,25 +1,25 @@ --- -title: "Java SDK Guide" -description: "Use the official AWS SDK for Java v2 with RustFS." +title: "Java-SDK-Anleitung" +description: "Verwenden Sie das offizielle AWS SDK für Java v2 mit RustFS." --- -RustFS ships no first-party Java SDK — it is S3-compatible, so you use the official AWS SDK for Java v2 configured to point at your RustFS server. +RustFS enthält kein eigenes Java-SDK. Der Dienst ist S3-kompatibel, daher verwenden Sie das offizielle AWS SDK für Java v2 und richten es auf Ihren RustFS-Server aus. -## 1. Prerequisites +## 1. Voraussetzungen -* Java 8 or later and Maven (or Gradle) -* A running RustFS instance (see the [Installation Guide](../../installation/index.md)) — the S3 API listens on port `9000`, the Console on port `9001` -* Access keys, set at install time via the `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` environment variables (see [Access Key Management](../../security-compliance/iam/access-token.md)) +* Java 8 oder höher und Maven (oder Gradle) +* Eine laufende RustFS-Instanz (siehe [Installationsanleitung](../../installation/index.md)). Die S3-API nimmt Verbindungen auf Port `9000` entgegen, die Console (Weboberfläche) auf Port `9001` +* Zugriffsschlüssel, die Sie bei der Installation über die Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` setzen (siehe [Zugriffsschlüssel-Verwaltung](../../security-compliance/iam/access-token.md)) -:::tip[Local test] +:::tip[Lokaler Test] -If you did not set credentials at install time, the server defaults to `rustfsadmin` / `rustfsadmin` — fine for a throwaway local trial, never for anything reachable by others. +Wenn Sie bei der Installation keine Anmeldedaten gesetzt haben, verwendet der Server standardmäßig `rustfsadmin` / `rustfsadmin`. Das reicht für einen wegwerfbaren lokalen Test, niemals für eine Instanz, die andere erreichen können. ::: -### 1.1 Maven Project Setup +### 1.1 Maven-Projekt einrichten -Create a new Maven project: +Legen Sie ein neues Maven-Projekt an: ```text rustfs-java-s3-demo/ @@ -32,9 +32,9 @@ rustfs-java-s3-demo/ └── RustfsS3Example.java ``` -### 1.2 Add Dependencies +### 1.2 Abhängigkeiten hinzufügen -Add AWS SDK dependencies in `pom.xml`: +Fügen Sie die AWS-SDK-Abhängigkeiten in `pom.xml` hinzu: ```xml title="pom.xml" @@ -46,15 +46,15 @@ Add AWS SDK dependencies in `pom.xml`: ``` -> Recommend using AWS SDK v2, which has more complete features and supports async, reactive, and other patterns. +Wir empfehlen das AWS SDK für Java v2. Es deckt mehr Funktionen ab und unterstützt asynchrone sowie reaktive Programmierung. --- -## 2. Connecting to RustFS +## 2. Verbindung mit RustFS -### 2.1 Complete Example +### 2.1 Vollständiges Beispiel -The following class compiles and runs as-is. Replace `localhost` with your server's IP address if RustFS runs on another machine, and fill in your own access keys: +Die folgende Klasse kompiliert und läuft unverändert. Ersetzen Sie `localhost` durch die IP-Adresse Ihres Servers, wenn RustFS auf einem anderen Rechner läuft, und tragen Sie Ihre eigenen Zugriffsschlüssel ein: ```java title="RustfsS3Example.java" package com.example; @@ -121,7 +121,7 @@ public class RustfsS3Example { } ``` -Expected output: +Erwartete Ausgabe: ```text Bucket created: my-bucket @@ -133,55 +133,55 @@ Deleted hello.txt --- -## 3. Common Issues and Troubleshooting +## 3. Fehlerbehebung -| Issue | Cause | Solution | -| -------------------------------------- | ------------------------------------ | ----------------------------------------- | -| `S3Exception: 301 Moved Permanently` | Path-style not enabled or region error | Set `.forcePathStyle(true)` and use region `us-east-1` | -| `ConnectException: Connection refused` | RustFS not started or incorrect port | Check RustFS status and port | -| `403 Forbidden` | AccessKey / SecretKey error | Check authentication configuration | -| Upload fails with no response | SDK defaults to HTTPS, RustFS only supports HTTP (or needs certificates) | Use `http://` address and configure `endpointOverride` | +| Problem | Ursache | Lösung | +| --- | --- | --- | +| `S3Exception: 301 Moved Permanently` | Pfadbasierte Adressierung (Path-Style) ist nicht aktiviert, oder die Region ist falsch | Setzen Sie `.forcePathStyle(true)` und verwenden Sie die Region `us-east-1` | +| `ConnectException: Connection refused` | RustFS ist nicht gestartet, oder der Port ist falsch | Prüfen Sie den Status und den Port von RustFS | +| `403 Forbidden` | Zugriffsschlüssel oder geheimer Zugriffsschlüssel ist falsch | Prüfen Sie Ihre Zugangsdaten | +| Upload schlägt ohne Antwort fehl | Das SDK verwendet standardmäßig HTTPS, und RustFS unterstützt nur HTTP (oder benötigt Zertifikate) | Verwenden Sie eine Adresse mit `http://` und setzen Sie `endpointOverride` | --- -## 4. Appendix +## 4. Anhang -### 4.1 Maven Package and Run +### 4.1 Mit Maven paketieren und ausführen -Package project: +Paketieren Sie das Projekt: ```bash mvn clean package ``` -Execute: +Führen Sie es aus: ```bash java -cp target/rustfs-java-s3-demo-1.0-SNAPSHOT.jar com.example.RustfsS3Example ``` -### 4.2 RustFS Configuration Recommendations +### 4.2 Empfohlene RustFS-Einstellungen -* Ensure SSL validation is disabled when service uses HTTP protocol. -* Enable CORS support (if used for web frontend). -* Recommend setting limits like `max_object_size` and `max_part_size` to prevent large file transfer failures. +* Wenn RustFS unverschlüsseltes HTTP ausliefert, deaktivieren Sie die Prüfung von TLS-Zertifikaten im SDK. +* Aktivieren Sie die CORS-Unterstützung, wenn Sie ein Web-Frontend verwenden. +* Wir empfehlen, Grenzwerte wie `max_object_size` und `max_part_size` zu setzen, damit die Übertragung großer Dateien nicht fehlschlägt. --- -The following advanced examples cover: +Die folgenden fortgeschrittenen Beispiele behandeln: -* Presigned URL generation and usage -* Multipart Upload complete process +* Erzeugen und Verwenden vorsignierter URLs +* den vollständigen Ablauf eines mehrteiligen Uploads --- -## 5. Java Advanced Features Examples +## 5. Fortgeschrittene Beispiele -### 5.1 Generate and Use Presigned URLs +### 5.1 Vorsignierte URLs erzeugen und verwenden -> Presigned URLs allow clients to temporarily access private objects without exposing credentials, widely used for browser direct upload or download file scenarios. +Vorsignierte URLs geben Clients zeitlich begrenzten Zugriff auf private Objekte, ohne Zugangsdaten offenzulegen. Sie werden häufig für direkte Uploads und Downloads aus einem Browser verwendet. -#### 5.1.1 Generate Download Link (GET) +#### 5.1.1 Download-Link erzeugen (GET) ```java import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; @@ -229,11 +229,11 @@ System.out.println("Presigned URL: " + presignedRequest.url()); Presigned URL: http://localhost:9000/my-bucket/hello.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&... ``` -> 🔗 Open the link in browser to access the object. +Öffnen Sie die URL in einem Browser, um auf das Objekt zuzugreifen. -#### 5.1.2 Upload Presigned URL (PUT) +#### 5.1.2 Vorsignierte Upload-URL (PUT) -Similarly, you can also generate upload URLs: +Sie können auch Upload-URLs erzeugen: ```java import software.amazon.awssdk.services.s3.model.PutObjectRequest; @@ -257,11 +257,11 @@ System.out.println("Upload URL: " + presignedPut.url()); --- -### 5.2 Implement Multipart Upload +### 5.2 Mehrteiligen Upload implementieren -> Multipart Upload is the recommended way for large file uploads, enabling resume from breakpoint during network fluctuations. +Der mehrteilige Upload ist der empfohlene Weg, große Dateien hochzuladen. Bei einer Unterbrechung des Netzwerks können Sie fehlgeschlagene Teile erneut senden, statt den gesamten Upload neu zu starten. -The examples below reuse the `s3` client from section 2 and need these additional imports: +Die folgenden Beispiele verwenden den Client `s3` aus Abschnitt 2 weiter und benötigen diese zusätzlichen Imports: ```java import software.amazon.awssdk.services.s3.model.*; @@ -271,7 +271,7 @@ import java.util.ArrayList; import java.util.List; ``` -#### 5.2.1 Start Multipart Upload +#### 5.2.1 Mehrteiligen Upload starten ```java CreateMultipartUploadRequest createRequest = CreateMultipartUploadRequest.builder() @@ -283,7 +283,7 @@ CreateMultipartUploadResponse createResponse = s3.createMultipartUpload(createRe String uploadId = createResponse.uploadId(); ``` -#### 5.2.2 Upload Each Part +#### 5.2.2 Jeden Teil hochladen ```java List completedParts = new ArrayList<>(); @@ -306,7 +306,7 @@ for (int i = 1; i <= 3; i++) { } ``` -#### 5.2.3 Complete Multipart Upload +#### 5.2.3 Mehrteiligen Upload abschließen ```java CompletedMultipartUpload completedUpload = CompletedMultipartUpload.builder() @@ -328,7 +328,7 @@ System.out.println("Multipart upload completed."); Multipart upload completed. ``` -#### 5.2.4 Abort Upload on Exception (Optional) +#### 5.2.4 Upload bei einer Ausnahme abbrechen (optional) ```java AbortMultipartUploadRequest abortRequest = AbortMultipartUploadRequest.builder() @@ -342,4 +342,4 @@ s3.abortMultipartUpload(abortRequest); --- -For other operations (object tagging, bucket policies, and more), see the [AWS SDK for Java v2 documentation](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/) — every S3-compatible call works against RustFS the same way. +Weitere Operationen (Objekt-Tagging, Bucket-Richtlinien und mehr) stehen in der [Dokumentation zum AWS SDK für Java v2](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/). Die meisten S3-Operationen funktionieren gegenüber RustFS auf dieselbe Weise. Ausnahmen stehen unter [S3-Kompatibilität](/de/reference/s3-compatibility). diff --git a/content/de/developer/sdk/javascript.md b/content/de/developer/sdk/javascript.md index f010b46fa..963c81c06 100644 --- a/content/de/developer/sdk/javascript.md +++ b/content/de/developer/sdk/javascript.md @@ -1,39 +1,39 @@ --- -title: "JavaScript SDK Guide" -description: "Use the official AWS SDK for JavaScript v3 with RustFS." +title: "JavaScript-SDK-Anleitung" +description: "Verwenden Sie das offizielle AWS SDK für JavaScript v3 mit RustFS." --- -## I. Overview +## Überblick -RustFS ships no first-party JavaScript SDK — it is S3-compatible, so you use the official AWS SDK for JavaScript (v3) configured to point at your RustFS server. This guide shows how to connect to RustFS and perform common object storage operations. +RustFS enthält kein eigenes JavaScript-SDK. Der Dienst ist S3-kompatibel, daher verwenden Sie das offizielle AWS SDK für JavaScript (v3) und richten es auf Ihren RustFS-Server aus. In dieser Anleitung verbinden Sie sich mit RustFS und führen gängige Operationen im Objektspeicher aus. -## II. Prerequisites +## Voraussetzungen -* Node.js 18 or later -* A running RustFS instance (see the [Installation Guide](../../installation/index.md)) — the S3 API listens on port `9000`, the Console on port `9001` -* Access keys, set at install time via the `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` environment variables (see [Access Key Management](../../security-compliance/iam/access-token.md)) +* Node.js 18 oder höher +* Eine laufende RustFS-Instanz (siehe [Installationsanleitung](../../installation/index.md)). Die S3-API nimmt Verbindungen auf Port `9000` entgegen, die Console (Weboberfläche) auf Port `9001` +* Zugriffsschlüssel, die Sie bei der Installation über die Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` setzen (siehe [Zugriffsschlüssel-Verwaltung](../../security-compliance/iam/access-token.md)) -:::tip[Local test] +:::tip[Lokaler Test] -If you did not set credentials at install time, the server defaults to `rustfsadmin` / `rustfsadmin` — fine for a throwaway local trial, never for anything reachable by others. +Wenn Sie bei der Installation keine Anmeldedaten gesetzt haben, verwendet der Server standardmäßig `rustfsadmin` / `rustfsadmin`. Das reicht für einen wegwerfbaren lokalen Test, niemals für eine Instanz, die andere erreichen können. ::: -### 2.1 SDK Installation +### SDK installieren -Install the required AWS SDK v3 modules with NPM: +Installieren Sie die erforderlichen Module des AWS SDK v3 mit npm: ```bash npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner ``` -The examples below use ES modules (`import`). Set `"type": "module"` in your `package.json`, or save the files with the `.mjs` extension. +Die folgenden Beispiele verwenden ES-Module (`import`). Setzen Sie `"type": "module"` in Ihrer `package.json`, oder speichern Sie die Dateien mit der Endung `.mjs`. --- -## III. Initializing the Client +## Client initialisieren -The following is a complete, runnable script. Replace `localhost` with your server's IP address if RustFS runs on another machine, and fill in your own access keys: +Das folgende Skript ist vollständig und ausführbar. Ersetzen Sie `localhost` durch die IP-Adresse Ihres Servers, wenn RustFS auf einem anderen Rechner läuft, und tragen Sie Ihre eigenen Zugriffsschlüssel ein: ```js title="main.mjs" import { S3Client, ListBucketsCommand } from "@aws-sdk/client-s3"; @@ -53,7 +53,7 @@ const { Buckets } = await s3.send(new ListBucketsCommand({})); console.log(Buckets?.map((b) => b.Name) ?? []); ``` -Run it: +Führen Sie es aus: ```bash node main.mjs @@ -63,13 +63,13 @@ node main.mjs [ 'my-bucket' ] ``` -All snippets below reuse this `s3` client. +Alle folgenden Ausschnitte verwenden diesen Client `s3` weiter. --- -## IV. Basic Operations +## Grundlegende Operationen -### 4.1 Create Bucket +### 4.1 Bucket erstellen ```js import { CreateBucketCommand } from "@aws-sdk/client-s3"; @@ -84,7 +84,7 @@ Bucket created --- -### 4.2 Upload Object +### 4.2 Objekt hochladen ```js import { PutObjectCommand } from "@aws-sdk/client-s3"; @@ -109,7 +109,7 @@ File uploaded --- -### 4.3 Download Object +### 4.3 Objekt herunterladen ```js import { GetObjectCommand } from "@aws-sdk/client-s3"; @@ -137,7 +137,7 @@ File downloaded --- -### 4.4 List Objects +### 4.4 Objekte auflisten ```js import { ListObjectsV2Command } from "@aws-sdk/client-s3"; @@ -152,7 +152,7 @@ hello.txt (12 bytes) --- -### 4.5 Delete Object +### 4.5 Objekt löschen ```js import { DeleteObjectCommand } from "@aws-sdk/client-s3"; @@ -167,11 +167,11 @@ File deleted --- -## V. Advanced Features +## Erweiterte Funktionen -### 5.1 Generate Presigned URLs +### 5.1 Vorsignierte URLs erzeugen -> Allows frontend or third parties to use temporary links for uploading/downloading files +Vorsignierte URLs ermöglichen Browser-Clients oder Dritten, Objekte über zeitlich begrenzte Links hoch- oder herunterzuladen. #### Download (GET) @@ -209,7 +209,7 @@ console.log("Presigned PUT URL:", url); --- -### 5.2 Multipart Upload +### 5.2 Mehrteiliger Upload ```js import { @@ -275,23 +275,23 @@ Multipart upload completed --- -## VI. Common Issues and Notes +## Fehlerbehebung -| Problem | Cause | Solution | -| --------------------------- | -------------------- | --------------------------------------- | -| SignatureDoesNotMatch | Wrong signature version | JS SDK v3 uses v4 by default, ensure RustFS supports v4 | -| EndpointConnectionError | Endpoint address misconfigured or not started | Check if RustFS address is accessible | -| NoSuchKey | File does not exist | Check if `Key` is spelled correctly | -| InvalidAccessKeyId / Secret | Credentials misconfigured | Check `accessKeyId` / `secretAccessKey` configuration | -| Upload failure (path issue) | Path-style not enabled | Set `forcePathStyle: true` | +| Problem | Ursache | Lösung | +| --- | --- | --- | +| SignatureDoesNotMatch | Die Signatur stimmt nicht überein | Das SDK v3 signiert standardmäßig mit SigV4. Prüfen Sie Zugangsdaten, Region und Endpunkt | +| EndpointConnectionError | Die Endpunktadresse ist falsch konfiguriert, oder der Dienst ist nicht gestartet | Prüfen Sie, ob die RustFS-Adresse erreichbar ist | +| NoSuchKey | Das Objekt ist nicht vorhanden | Prüfen Sie, ob `Key` richtig geschrieben ist | +| InvalidAccessKeyId / Secret | Zugangsdaten sind falsch konfiguriert | Prüfen Sie die Konfiguration von `accessKeyId` und `secretAccessKey` | +| Upload schlägt fehl (Pfadproblem) | Pfadbasierte Adressierung (Path-Style) ist nicht aktiviert | Setzen Sie `forcePathStyle: true` | --- -## VII. Appendix: Frontend Upload Adaptation +## Anhang: Uploads aus dem Browser -Using presigned URLs allows browsers to upload files directly without passing AccessKey. +Mit vorsignierten URLs können Browser Objekte direkt hochladen, ohne Zugriff auf Ihre Zugangsdaten. -Frontend (HTML+JS) upload example: +Beispiel für einen Upload im Frontend (HTML und JavaScript): ```html @@ -312,4 +312,4 @@ Frontend (HTML+JS) upload example: ``` -For other operations (object tagging, bucket policies, and more), see the [AWS SDK for JavaScript v3 documentation](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) — every S3-compatible call works against RustFS the same way. +Weitere Operationen (Objekt-Tagging, Bucket-Richtlinien und mehr) stehen in der [Dokumentation zum AWS SDK für JavaScript v3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/). Die meisten S3-Operationen funktionieren gegenüber RustFS auf dieselbe Weise. Ausnahmen stehen unter [S3-Kompatibilität](/de/reference/s3-compatibility). diff --git a/content/de/developer/sdk/other.md b/content/de/developer/sdk/other.md index 4b4380965..8f31b457c 100644 --- a/content/de/developer/sdk/other.md +++ b/content/de/developer/sdk/other.md @@ -1,43 +1,43 @@ --- -title: "Other SDKs" -description: "This article mainly explains the usage of various other language SDKs in RustFS." +title: "Weitere SDKs" +description: "Verbinden Sie sich aus Sprachen ohne offizielles AWS-SDK mit RustFS." --- -If AWS S3 doesn't officially support your language, you can adopt the following strategies to integrate with RustFS: +Wenn AWS für Ihre Sprache kein offizielles SDK bereitstellt, können Sie RustFS auf einem der folgenden Wege integrieren: -## 1. Use HTTP Interface Direct Requests (Based on S3 API Protocol) +## 1. HTTP-Anfragen direkt an die S3-API senden -The S3 protocol is a standard RESTful API. You can encapsulate access logic yourself using any language that supports HTTP requests (such as C, Rust, Lua, Erlang). +Das S3-Protokoll ist eine standardmäßige REST-API. Sie können die Client-Logik selbst in jeder Sprache implementieren, die HTTP-Anfragen senden kann (zum Beispiel C, Rust, Lua oder Erlang). -### Key points include: +### Zentrale Schritte -* **Signature Algorithm**: Implement AWS Signature Version 4 signature (more complex) -* **Construct correct Headers and Canonical Request** -* **Use HTTPS/HTTP client to send requests** +* **Request-Signierung**: Implementieren Sie AWS Signature Version 4 (der aufwendigste Teil). +* **Header und kanonische Anfrage**: Erstellen Sie die kanonische Anfrage und die erforderlichen Header. +* **HTTP-Client**: Senden Sie die signierte Anfrage mit einem HTTP- oder HTTPS-Client. -👉 Recommended to reference open-source project signature implementations, for example: +Wir empfehlen, vorhandene Open-Source-Implementierungen der Request-Signierung heranzuziehen, zum Beispiel: * [https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) --- -## 2. Call CLI Tools or Middleware Services of Existing SDKs +## 2. Die AWS CLI oder einen Dienst auf Basis eines vorhandenen SDK verwenden -If you don't want to implement signatures yourself, you can: +Wenn Sie Signaturen nicht selbst implementieren möchten, können Sie: -### 2.1. Use AWS CLI tools with existing language support: +### 2.1. Die AWS CLI aufrufen -For example, call through Shell: +Führen Sie zum Beispiel den folgenden Befehl aus Ihrer Anwendung über eine Shell aus: ```bash aws s3 cp local.txt s3://mybucket/myfile.txt --endpoint-url http://rustfs.local:9000 ``` -Or write a simple relay service using Node.js/Python SDK, and your language uploads/downloads by calling this service. +Alternativ bauen Sie einen kleinen Relay-Dienst mit einem SDK für Node.js oder Python und rufen ihn aus Ihrer Anwendung auf, um Objekte hoch- oder herunterzuladen. -### 2.2. Set up a Proxy (such as Flask, FastAPI, Express) +### 2.2. Einen Proxy-Dienst betreiben (zum Beispiel Flask, FastAPI oder Express) -Let clients that don't support S3 call your encapsulated HTTP API: +Stellen Sie eine HTTP-API bereit, die Clients ohne S3-Unterstützung aufrufen können: ```http POST /upload -> Service internally calls SDK to upload objects to RustFS @@ -46,33 +46,33 @@ GET /presigned-url -> Generate presigned URL for frontend/client use --- -## 3. Find Third-Party Community SDKs +## 3. Community-SDKs von Drittanbietern finden -Although AWS doesn't have official SDKs, some language communities have developed unofficial S3 clients. For example: +Suchen Sie für Sprachen ohne offizielles AWS-SDK nach S3-Clients, die von der Community gepflegt werden. Zum Beispiel: * Haskell: `amazonka-s3` -* Rust: `rusoto` (deprecated) or `aws-sdk-rust` -* OCaml: May implement through `cohttp` yourself -* Delphi: Has commercial libraries supporting S3 protocol +* Rust: `rusoto` (veraltet) oder `aws-sdk-rust` +* OCaml: Erstellen Sie einen eigenen Client auf Basis von `cohttp` +* Delphi: Es gibt kommerzielle Bibliotheken mit S3-Unterstützung -Community SDKs vary greatly in stability, so you should evaluate activity, documentation, and compatibility before use. +Community-SDKs unterscheiden sich stark in der Stabilität. Prüfen Sie vor der Verwendung Aktivität, Dokumentation und Kompatibilität. --- -## 4. Delegate Core Upload Logic to Platform Hosting +## 4. Direkt von Clients mit vorsignierten URLs hochladen -For example: +Zum Beispiel: -* Delegate frontend (Web/Mobile) upload tasks to browser or App side execution (using presigned URLs) -* Backend uses Node.js/Python/Go and other proxies to implement upload logic +* Verwenden Sie vorsignierte URLs, um direkt aus einem Browser oder einer mobilen App hochzuladen. +* Implementieren Sie die Upload-Logik in einem Backend-Dienst (zum Beispiel Node.js, Python oder Go). --- -## Summary Recommendations +## Ansatz wählen -| Scenario | Recommended Solution | -| ------------- | ---------------------------------- | -| Need complete control/embedded environment | Implement Signature V4 self-signing | -| Weak language support but has Shell | Call upload through AWS CLI | -| Can deploy relay service | Use Python/Node to build S3 API gateway | -| Frontend upload | Use presigned URLs | +| Situation | Empfohlener Ansatz | +| --- | --- | +| Sie brauchen volle Kontrolle oder zielen auf eine eingebettete Umgebung | Implementieren Sie die SigV4-Signierung selbst | +| Eingeschränkte SDK-Unterstützung, aber eine Shell ist verfügbar | Laden Sie mit der AWS CLI hoch | +| Sie können einen Relay-Dienst bereitstellen | Bauen Sie ein kleines S3-Gateway mit Python oder Node.js | +| Upload aus dem Frontend | Verwenden Sie vorsignierte URLs | diff --git a/content/de/developer/sdk/python.md b/content/de/developer/sdk/python.md index 672504524..217b6ebda 100644 --- a/content/de/developer/sdk/python.md +++ b/content/de/developer/sdk/python.md @@ -1,37 +1,37 @@ --- -title: "Python SDK Guide" -description: "Use the official AWS SDK for Python (Boto3) with RustFS." +title: "Python-SDK-Anleitung" +description: "Verwenden Sie das offizielle AWS SDK für Python (Boto3) mit RustFS." --- -## 1. Overview +## 1. Überblick -RustFS ships no first-party SDKs — it is S3-compatible, so you use the official AWS SDK for Python, [Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html), configured to point at your RustFS server. +RustFS enthält keine eigenen SDKs. Der Dienst ist S3-kompatibel, daher verwenden Sie das offizielle AWS SDK für Python, [Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html), und richten es auf Ihren RustFS-Server aus. -This guide covers: +Diese Anleitung behandelt: -* Bucket creation/deletion -* Object upload/download/deletion -* Listing objects -* Generating presigned URLs -* Multipart upload for large files +* das Erstellen und Löschen von Buckets +* das Hochladen, Herunterladen und Löschen von Objekten +* das Auflisten von Objekten +* das Erzeugen vorsignierter URLs +* den mehrteiligen Upload für große Dateien --- -## 2. Prerequisites +## 2. Voraussetzungen -* Python 3.8 or later -* A running RustFS instance (see the [Installation Guide](../../installation/index.md)) — the S3 API listens on port `9000`, the Console on port `9001` -* Access keys, set at install time via the `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` environment variables (see [Access Key Management](../../security-compliance/iam/access-token.md)) +* Python 3.8 oder höher +* Eine laufende RustFS-Instanz (siehe [Installationsanleitung](../../installation/index.md)). Die S3-API nimmt Verbindungen auf Port `9000` entgegen, die Console (Weboberfläche) auf Port `9001` +* Zugriffsschlüssel, die Sie bei der Installation über die Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` setzen (siehe [Zugriffsschlüssel-Verwaltung](../../security-compliance/iam/access-token.md)) -:::tip[Local test] +:::tip[Lokaler Test] -If you did not set credentials at install time, the server defaults to `rustfsadmin` / `rustfsadmin` — fine for a throwaway local trial, never for anything reachable by others. +Wenn Sie bei der Installation keine Anmeldedaten gesetzt haben, verwendet der Server standardmäßig `rustfsadmin` / `rustfsadmin`. Das reicht für einen wegwerfbaren lokalen Test, niemals für eine Instanz, die andere erreichen können. ::: -### 2.1 Install Boto3 +### 2.1 Boto3 installieren -We recommend using a virtual environment: +Wir empfehlen eine virtuelle Umgebung: ```bash python3 -m venv venv @@ -39,13 +39,13 @@ source venv/bin/activate pip install boto3 ``` -> Boto3 depends on `botocore`, which will be installed automatically. +> Boto3 hängt von `botocore` ab. Das Paket wird automatisch installiert. --- -## 3. Connecting to RustFS +## 3. Verbindung mit RustFS -The following is a complete, runnable script. Replace `localhost` with your server's IP address if RustFS runs on another machine, and fill in your own access keys: +Das folgende Skript ist vollständig und ausführbar. Ersetzen Sie `localhost` durch die IP-Adresse Ihres Servers, wenn RustFS auf einem anderen Rechner läuft, und tragen Sie Ihre eigenen Zugriffsschlüssel ein: ```python title="main.py" import boto3 @@ -68,26 +68,26 @@ for bucket in response['Buckets']: print(bucket['Name']) ``` -Run it: +Führen Sie es aus: ```bash python main.py ``` -:::note[Client parameters explained] +:::note[Erläuterung der Client-Parameter] -- `endpoint_url` — points to your RustFS S3 API (port `9000`, not the Console port `9001`) -- `signature_version='s3v4'` — RustFS supports v4 signatures -- `region_name='us-east-1'` — RustFS's default region -- `addressing_style='path'` — RustFS uses path-style URLs by default; virtual-host style requires `RUSTFS_SERVER_DOMAINS` +- `endpoint_url`: zeigt auf Ihre RustFS-S3-API (Port `9000`, nicht der Port `9001` der Console) +- `signature_version='s3v4'`: RustFS unterstützt v4-Signaturen +- `region_name='us-east-1'`: die Standardregion von RustFS +- `addressing_style='path'`: RustFS verwendet standardmäßig pfadbasierte Adressierung (Path-Style). Für die Adressierung im Virtual-Hosted-Stil ist `RUSTFS_SERVER_DOMAINS` erforderlich ::: --- -## 4. Basic Operations +## 4. Grundlegende Operationen -### 4.1 Create Bucket +### 4.1 Bucket erstellen ```python bucket_name = 'my-bucket' @@ -105,7 +105,7 @@ Bucket my-bucket created. --- -### 4.2 Upload File +### 4.2 Datei hochladen ```python s3.upload_file('/path/to/hello.txt', bucket_name, 'hello.txt') @@ -118,7 +118,7 @@ File uploaded. --- -### 4.3 Download File +### 4.3 Datei herunterladen ```python s3.download_file(bucket_name, 'hello.txt', 'hello-downloaded.txt') @@ -131,7 +131,7 @@ File downloaded. --- -### 4.4 List Objects +### 4.4 Objekte auflisten ```python response = s3.list_objects_v2(Bucket=bucket_name) @@ -145,7 +145,7 @@ for obj in response.get('Contents', []): --- -### 4.5 Delete Object and Bucket +### 4.5 Objekt und Bucket löschen ```python s3.delete_object(Bucket=bucket_name, Key='hello.txt') @@ -162,11 +162,11 @@ Bucket deleted. --- -## 5. Advanced Features +## 5. Erweiterte Funktionen -### 5.1 Generate Presigned URLs +### 5.1 Vorsignierte URLs erzeugen -#### 5.1.1 Download Link (GET) +#### 5.1.1 Download-Link (GET) ```python url = s3.generate_presigned_url( @@ -182,7 +182,7 @@ print('Presigned GET URL:', url) Presigned GET URL: http://localhost:9000/my-bucket/hello.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256&... ``` -#### 5.1.2 Upload Link (PUT) +#### 5.1.2 Upload-Link (PUT) ```python url = s3.generate_presigned_url( @@ -194,7 +194,7 @@ url = s3.generate_presigned_url( print('Presigned PUT URL:', url) ``` -You can use the `curl` tool to upload: +Sie können mit `curl` hochladen: ```bash curl -X PUT --upload-file /path/to/hello.txt "http://localhost:9000/my-bucket/upload-by-url.txt?X-Amz-Algorithm=..." @@ -202,9 +202,9 @@ curl -X PUT --upload-file /path/to/hello.txt "http://localhost:9000/my-bucket/up --- -### 5.2 Multipart Upload +### 5.2 Mehrteiliger Upload -Suitable for files larger than 10 MB, allows manual control of each part. +Verwenden Sie den mehrteiligen Upload für Dateien über 10 MB, wenn Sie jeden Teil steuern müssen. ```python file_path = 'largefile.bin' @@ -260,18 +260,18 @@ Multipart upload complete. --- -## 6. Common Issue Troubleshooting +## 6. Fehlerbehebung -| Issue | Cause | Solution | -| ------------------------- | ----------------- | -------------------------------------------------------------- | -| `SignatureDoesNotMatch` | Not using v4 signature | Set `signature_version='s3v4'` | -| `EndpointConnectionError` | Wrong RustFS address or service not started | Check endpoint and RustFS service status | -| `AccessDenied` | Wrong credentials or insufficient permissions | Check AccessKey/SecretKey or bucket policies | -| `PermanentRedirect` / wrong bucket URL | Path-style not enabled | Set `s3={'addressing_style': 'path'}` in the `Config` | +| Problem | Ursache | Lösung | +| --- | --- | --- | +| `SignatureDoesNotMatch` | Es wird keine v4-Signatur verwendet | Setzen Sie `signature_version='s3v4'` | +| `EndpointConnectionError` | Falsche RustFS-Adresse, oder der Dienst ist nicht gestartet | Prüfen Sie den Endpunkt und den Status des RustFS-Dienstes | +| `AccessDenied` | Falsche Zugangsdaten oder unzureichende Berechtigungen | Prüfen Sie Zugriffsschlüssel, geheimen Zugriffsschlüssel und die Bucket-Richtlinien | +| `PermanentRedirect` oder falsche Bucket-URL | Pfadbasierte Adressierung ist nicht aktiviert | Setzen Sie in der `Config` den Wert `s3={'addressing_style': 'path'}` | --- -## 7. Appendix: Quick Upload/Download Script Template +## 7. Anhang: Kurzes Skript zum Hoch- und Herunterladen ```python def upload_file(local_path, bucket, object_key): @@ -284,6 +284,6 @@ def download_file(bucket, object_key, local_path): print(f"Downloaded s3://{bucket}/{object_key} to {local_path}") ``` -For other operations (object tagging, bucket policies, and more), see the [Boto3 S3 documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html) — every S3-compatible call works against RustFS the same way. +Weitere Operationen (Objekt-Tagging, Bucket-Richtlinien und mehr) stehen in der [Boto3-S3-Dokumentation](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html). Die meisten S3-Operationen funktionieren gegenüber RustFS auf dieselbe Weise. Ausnahmen stehen unter [S3-Kompatibilität](/de/reference/s3-compatibility). -If you prefer native async support and full type hints, the community-driven [capo](https://github.com/kap-sh/capo) SDK also works with RustFS — see the [capo (Python) integration guide](../integration/others/capo.md). +Wenn Sie native asynchrone Unterstützung und vollständige Typhinweise bevorzugen, funktioniert auch das von der Community entwickelte SDK [capo](https://github.com/kap-sh/capo) mit RustFS. Lesen Sie die [Integrationsanleitung für capo (Python)](../integration/others/capo.md). diff --git a/content/de/developer/sdk/rust.md b/content/de/developer/sdk/rust.md index 9d8181348..22a2438d0 100644 --- a/content/de/developer/sdk/rust.md +++ b/content/de/developer/sdk/rust.md @@ -1,23 +1,23 @@ --- -title: "Rust SDK Guide" -description: "Operate RustFS instances through the AWS SDK for Rust, including creation and deletion of buckets and objects." +title: "Rust-SDK-Anleitung" +description: "Erstellen und löschen Sie Buckets und Objekte in RustFS mit dem AWS SDK für Rust." --- -RustFS ships no first-party Rust client crate — it is fully S3-compatible, so you use the official AWS SDK for Rust (`aws-sdk-s3`) configured to point at your RustFS server. Through the SDK, you can operate RustFS, including creation and deletion of buckets/objects, file upload and download, etc. +RustFS enthält kein eigenes Rust-Client-Crate. Der Dienst ist S3-kompatibel, daher verwenden Sie das offizielle AWS SDK für Rust (`aws-sdk-s3`) und richten es auf Ihren RustFS-Server aus. Mit dem SDK erstellen und löschen Sie Buckets und laden Objekte hoch, herunter und löschen sie. -## Prerequisites +## Voraussetzungen -- Rust 1.78 or later (install via [rustup](https://rustup.rs/)) -- An available RustFS instance (refer to [Installation Guide](../../installation/index.md)) — the S3 API listens on port `9000`, the Console on port `9001` -- Access keys, set at install time via the `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` environment variables (refer to [Access Key Management](../../security-compliance/iam/access-token.md)) +- Rust 1.78 oder höher (Installation über [rustup](https://rustup.rs/)) +- Eine verfügbare RustFS-Instanz (siehe [Installationsanleitung](../../installation/index.md)). Die S3-API nimmt Verbindungen auf Port `9000` entgegen, die Console (Weboberfläche) auf Port `9001` +- Zugriffsschlüssel, die Sie bei der Installation über die Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` setzen (siehe [Zugriffsschlüssel-Verwaltung](../../security-compliance/iam/access-token.md)) -:::tip[Local test] +:::tip[Lokaler Test] -If you did not set credentials at install time, the server defaults to `rustfsadmin` / `rustfsadmin` — fine for a throwaway local trial, never for anything reachable by others. +Wenn Sie bei der Installation keine Anmeldedaten gesetzt haben, verwendet der Server standardmäßig `rustfsadmin` / `rustfsadmin`. Das reicht für einen wegwerfbaren lokalen Test, niemals für eine Instanz, die andere erreichen können. ::: -Create a project and add the dependencies: +Legen Sie ein Projekt an und fügen Sie die Abhängigkeiten hinzu: ```bash cargo new rustfs-rust-demo && cd rustfs-rust-demo @@ -25,7 +25,7 @@ cargo add aws-config aws-sdk-s3 anyhow cargo add tokio --features full ``` -Your `Cargo.toml` should contain: +Ihre `Cargo.toml` sollte Folgendes enthalten: ```toml title="Cargo.toml" [dependencies] @@ -35,9 +35,9 @@ aws-sdk-s3 = "1" tokio = { version = "1", features = ["full"] } ``` -## Initializing the Client +## Client initialisieren -The following is a complete, runnable program. It loads the connection settings from environment variables, initializes the S3 client, and lists your buckets: +Das folgende Programm ist vollständig und ausführbar. Es lädt die Verbindungseinstellungen aus Umgebungsvariablen, initialisiert den S3-Client und listet Ihre Buckets auf: ```rust title="src/main.rs" use anyhow::Result; @@ -108,11 +108,11 @@ async fn main() -> Result<()> { :::note -These environment variable names (`RUSTFS_ENDPOINT_URL`, `RUSTFS_REGION`, `RUSTFS_ACCESS_KEY_ID`, `RUSTFS_SECRET_ACCESS_KEY`) are just this example's client-side conventions — they are read by your program, not by RustFS. They are distinct from the server-side `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` variables used when installing RustFS. +Diese Namen von Umgebungsvariablen (`RUSTFS_ENDPOINT_URL`, `RUSTFS_REGION`, `RUSTFS_ACCESS_KEY_ID`, `RUSTFS_SECRET_ACCESS_KEY`) sind nur Konventionen auf der Client-Seite dieses Beispiels. Ihr Programm liest sie, nicht RustFS. Sie unterscheiden sich von den serverseitigen Variablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY`, die bei der Installation von RustFS verwendet werden. ::: -Run it (replace `localhost` with your server's IP address if RustFS runs on another machine): +Führen Sie das Programm aus (ersetzen Sie `localhost` durch die IP-Adresse Ihres Servers, wenn RustFS auf einem anderen Rechner läuft): ```bash export RUSTFS_ENDPOINT_URL="http://localhost:9000" @@ -126,9 +126,9 @@ cargo run Bucket: Some("my-bucket") ``` -You can now use the client for the operations below. Each snippet runs inside `main`, reusing `rustfs_client`. +Sie können den Client nun für die folgenden Operationen verwenden. Jeder Ausschnitt läuft in `main` und verwendet `rustfs_client` weiter. -## Create Bucket +## Bucket erstellen ```rust match rustfs_client @@ -151,7 +151,7 @@ match rustfs_client Bucket created successfully ``` -## Delete Bucket +## Bucket löschen ```rust match rustfs_client @@ -174,7 +174,7 @@ match rustfs_client Bucket deleted successfully ``` -## List Buckets +## Buckets auflisten ```rust match rustfs_client.list_buckets().send().await { @@ -196,7 +196,7 @@ Total buckets number is 1 Bucket: Some("my-bucket") ``` -## List Objects +## Objekte auflisten ```rust match rustfs_client @@ -223,16 +223,16 @@ Total objects number is 1 Object: Some("hello.txt") ``` -## Upload File +## Datei hochladen -Add these imports at the top of `src/main.rs`: +Fügen Sie diese Imports am Anfang von `src/main.rs` hinzu: ```rust use aws_sdk_s3::primitives::ByteStream; use tokio::fs; ``` -Then upload a local file: +Laden Sie anschließend eine lokale Datei hoch: ```rust let data = fs::read("/path/to/hello.txt").await.expect("can not open the file"); @@ -259,7 +259,7 @@ match rustfs_client Object uploaded successfully, res: PutObjectOutput { e_tag: Some("\"...\""), ... } ``` -## Download Object +## Objekt herunterladen ```rust match rustfs_client @@ -284,4 +284,4 @@ match rustfs_client Object content: hello rustfs ``` -For other operations (presigned URLs, multipart uploads, and more), see the [AWS SDK for Rust documentation](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/) — every S3-compatible call works against RustFS the same way. +Weitere Operationen (vorsignierte URLs, mehrteilige Uploads und mehr) stehen in der [Dokumentation zum AWS SDK für Rust](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/). Die meisten S3-Operationen funktionieren gegenüber RustFS auf dieselbe Weise. Ausnahmen stehen unter [S3-Kompatibilität](/de/reference/s3-compatibility). diff --git a/content/de/developer/sdk/typescript.md b/content/de/developer/sdk/typescript.md index d26b7a938..b803eda21 100644 --- a/content/de/developer/sdk/typescript.md +++ b/content/de/developer/sdk/typescript.md @@ -1,32 +1,32 @@ --- -title: "RustFS TypeScript SDK Usage Guide" -description: "Operate RustFS from TypeScript with the AWS SDK for JavaScript v3, including creation and deletion of buckets and objects." +title: "TypeScript-SDK-Anleitung" +description: "Führen Sie aus TypeScript mit dem AWS SDK für JavaScript v3 Operationen auf RustFS aus, einschließlich des Erstellens und Löschens von Buckets und Objekten." --- -RustFS ships no first-party TypeScript SDK — it is fully S3-compatible, so you use the official AWS SDK for JavaScript v3 (which ships its own TypeScript type definitions) configured to point at your RustFS server. Through the SDK, you can operate RustFS, including creation and deletion of buckets/objects, file upload and download, etc. +RustFS enthält kein eigenes TypeScript-SDK. Der Dienst ist S3-kompatibel, daher verwenden Sie das offizielle AWS SDK für JavaScript v3 (es enthält TypeScript-Typdefinitionen) und richten es auf Ihren RustFS-Server aus. Mit dem SDK erstellen und löschen Sie Buckets und laden Objekte hoch, herunter und löschen sie. -## Prerequisites +## Voraussetzungen -- Node.js 18 or later (the examples use ES modules — set `"type": "module"` in your `package.json`) -- An available RustFS instance (refer to [Installation Guide](../../installation/index.md) for installation) — the S3 API listens on port `9000`, the Console on port `9001` -- Access keys, set at install time via the `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` environment variables (refer to [Access Key Management](../../security-compliance/iam/access-token.md) for creation) +- Node.js 18 oder höher (die Beispiele verwenden ES-Module; setzen Sie `"type": "module"` in Ihrer `package.json`) +- Eine laufende RustFS-Instanz (siehe [Installationsanleitung](../../installation/index.md)). Die S3-API nimmt Verbindungen auf Port `9000` entgegen, die Console (Weboberfläche) auf Port `9001` +- Zugriffsschlüssel, die Sie bei der Installation über die Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` setzen (zum Anlegen siehe [Zugriffsschlüssel-Verwaltung](../../security-compliance/iam/access-token.md)) -:::tip[Local test] +:::tip[Lokaler Test] -If you did not set credentials at install time, the server defaults to `rustfsadmin` / `rustfsadmin` — fine for a throwaway local trial, never for anything reachable by others. +Wenn Sie bei der Installation keine Anmeldedaten gesetzt haben, verwendet der Server standardmäßig `rustfsadmin` / `rustfsadmin`. Das reicht für einen wegwerfbaren lokalen Test, niemals für eine Instanz, die andere erreichen können. ::: -Install the dependencies: +Installieren Sie die Abhängigkeiten: ```bash npm install @aws-sdk/client-s3 npm install --save-dev typescript tsx @types/node ``` -## Initializing the Client +## Client initialisieren -The following is a complete, runnable example. Replace `localhost` with your server's IP address if RustFS runs on another machine, and fill in your own access keys: +Das folgende Beispiel ist vollständig und ausführbar. Ersetzen Sie `localhost` durch die IP-Adresse Ihres Servers, wenn RustFS auf einem anderen Rechner läuft, und tragen Sie Ihre eigenen Zugriffsschlüssel ein: ```typescript title="main.ts" import { @@ -55,7 +55,7 @@ const response = await rustfs_client.send(new ListBucketsCommand({})); console.log(response.Buckets?.map((bucket) => bucket.Name) ?? []); ``` -Run it: +Führen Sie es aus: ```bash npx tsx main.ts @@ -65,9 +65,9 @@ npx tsx main.ts [ 'my-bucket' ] ``` -Then use the constructed `rustfs_client` for the operations below. +Verwenden Sie anschließend den erzeugten Client `rustfs_client` für die folgenden Operationen. -## Create Bucket +## Bucket erstellen ```typescript async function createBucket() { @@ -88,7 +88,7 @@ async function createBucket() { Bucket created: /my-bucket ``` -## Delete Bucket +## Bucket löschen ```typescript async function deleteBucket() { @@ -109,7 +109,7 @@ async function deleteBucket() { Bucket deleted ``` -## List Buckets +## Buckets auflisten ```typescript async function listBuckets() { @@ -126,7 +126,7 @@ async function listBuckets() { my-bucket ``` -## List Objects +## Objekte auflisten ```typescript async function listObjects() { @@ -147,7 +147,7 @@ async function listObjects() { test/hello.txt (12 bytes) ``` -## Upload File +## Datei hochladen ```typescript async function uploadFile() { @@ -170,7 +170,7 @@ async function uploadFile() { Object uploaded ``` -## Download Object +## Objekt herunterladen ```typescript async function getObject() { @@ -201,4 +201,4 @@ async function getObject() { Object content: hello rustfs ``` -For other operations (presigned URLs, multipart uploads, and more), see the [AWS SDK for JavaScript v3 documentation](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) — every S3-compatible call works against RustFS the same way. +Weitere Operationen (vorsignierte URLs, mehrteilige Uploads und mehr) stehen in der [Dokumentation zum AWS SDK für JavaScript v3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/). Die meisten S3-Operationen funktionieren gegenüber RustFS auf dieselbe Weise. Ausnahmen stehen unter [S3-Kompatibilität](/de/reference/s3-compatibility). diff --git a/content/de/index.mdx b/content/de/index.mdx index ddc2b6fcc..68452df85 100644 --- a/content/de/index.mdx +++ b/content/de/index.mdx @@ -16,7 +16,7 @@ description: "Installieren Sie RustFS unter Linux, in Containern, auf Kubernetes -

Self-Hosting

+

Selbst betreiben

-

Cloud-Provider

+

Cloud-Anbieter

- + + -Clone the RustFS source repository to use the chart at `helm/rustfs`: +Klonen Sie das RustFS-Quell-Repository, um das Chart unter `helm/rustfs` zu verwenden: ```bash git clone https://github.com/rustfs/rustfs.git @@ -40,9 +40,9 @@ export RUSTFS_CHART=./helm/rustfs ``` - + -Add the RustFS repository listed on [Artifact Hub](https://artifacthub.io/packages/helm/rustfs/rustfs), then update the local repository index: +Fügen Sie das auf [Artifact Hub](https://artifacthub.io/packages/helm/rustfs/rustfs) aufgeführte RustFS-Repository hinzu und aktualisieren Sie anschließend den lokalen Repository-Index: ```bash helm repo add rustfs https://charts.rustfs.com @@ -53,9 +53,9 @@ export RUSTFS_CHART=rustfs/rustfs -## 2. Install standalone mode +## 2. Standalone-Modus installieren -Create a values file for a one-Pod development deployment: +Legen Sie eine Values-Datei für eine Entwicklungsumgebung mit einem Pod an: ```yaml title="standalone-values.yaml" mode: @@ -78,7 +78,7 @@ ingress: enabled: false ``` -Replace `standard` with a StorageClass in your cluster, then install: +Ersetzen Sie `standard` durch eine StorageClass in Ihrem Cluster und installieren Sie anschließend: ```bash helm upgrade --install rustfs "$RUSTFS_CHART" \ @@ -87,9 +87,9 @@ helm upgrade --install rustfs "$RUSTFS_CHART" \ -f standalone-values.yaml ``` -## 3. Install distributed mode +## 3. Verteilten Modus installieren -For a distributed cluster, set the Pod and drive counts explicitly. Total data drives equal `replicaCount * drivesPerNode`. +Setzen Sie für einen verteilten Cluster die Anzahl der Pods und Laufwerke ausdrücklich. Die Gesamtzahl der Datenlaufwerke entspricht `replicaCount * drivesPerNode`. ```yaml title="distributed-values.yaml" mode: @@ -115,7 +115,7 @@ ingress: enabled: false ``` -The example creates four Pods and eight data PVCs. Ensure the cluster can schedule all Pods and provision all PVCs, then install: +Das Beispiel erzeugt vier Pods und acht Daten-PVCs. Stellen Sie sicher, dass der Cluster alle Pods einplanen und alle PVCs bereitstellen kann, und installieren Sie anschließend: ```bash helm upgrade --install rustfs "$RUSTFS_CHART" \ @@ -124,45 +124,45 @@ helm upgrade --install rustfs "$RUSTFS_CHART" \ -f distributed-values.yaml ``` -:::warning[Choose the topology before installation] +:::warning[Topologie vor der Installation festlegen] -Kubernetes does not allow updates to StatefulSet `volumeClaimTemplates`. Changing `drivesPerNode` later requires StatefulSet recreation or a new installation. +Kubernetes erlaubt keine Aktualisierung der `volumeClaimTemplates` eines StatefulSet. Eine spätere Änderung von `drivesPerNode` erfordert, dass das StatefulSet neu angelegt oder die Installation neu ausgeführt wird. ::: -## 4. Verify and access RustFS +## 4. RustFS prüfen und erreichen ```bash kubectl -n rustfs get pods,pvc,services kubectl -n rustfs rollout status statefulset/rustfs ``` -Standalone mode creates a Deployment instead of a StatefulSet. Check it with: +Der Standalone-Modus erzeugt ein Deployment anstelle eines StatefulSet. Prüfen Sie es mit: ```bash kubectl -n rustfs rollout status deployment/rustfs ``` -Forward the S3 API and Console to your workstation: +Leiten Sie die S3-API und die Console auf Ihre Arbeitsstation weiter: ```bash kubectl -n rustfs port-forward svc/rustfs 9000:9000 9001:9001 ``` -Use `http://localhost:9000` as the S3 endpoint and open `http://localhost:9001` for the Console. +Verwenden Sie `http://localhost:9000` als S3-Endpunkt und öffnen Sie `http://localhost:9001` für die Console. -## Key values +## Wichtige Values -| Value | Purpose | Chart default | +| Wert | Zweck | Chart-Standard | |-------|---------|---------------| -| `mode.standalone.enabled` | Enable one-Pod standalone mode | `false` | -| `mode.distributed.enabled` | Enable distributed mode | `true` | -| `replicaCount` | Distributed Pod count | `4` | -| `drivesPerNode` | Data PVCs per Pod | Inferred from `replicaCount` | -| `storageclass.name` | StorageClass for PVCs | `local-path` | -| `storageclass.dataStorageSize` | Size of each data PVC | `256Mi` | -| `storageclass.logStorageSize` | Size of each log PVC | `256Mi` | -| `service.endpoint.port` | S3 API port | `9000` | -| `service.console.port` | Console port | `9001` | - -We recommend setting storage sizes explicitly; the chart defaults are intended only for basic evaluation. \ No newline at end of file +| `mode.standalone.enabled` | Standalone-Modus mit einem Pod aktivieren | `false` | +| `mode.distributed.enabled` | Verteilten Modus aktivieren | `true` | +| `replicaCount` | Anzahl der Pods im verteilten Modus | `4` | +| `drivesPerNode` | Daten-PVCs pro Pod | Aus `replicaCount` abgeleitet | +| `storageclass.name` | StorageClass für PVCs | `local-path` | +| `storageclass.dataStorageSize` | Größe jedes Daten-PVC | `256Mi` | +| `storageclass.logStorageSize` | Größe jedes Protokoll-PVC | `256Mi` | +| `service.endpoint.port` | Port der S3-API | `9000` | +| `service.console.port` | Console-Port | `9001` | + +Wir empfehlen, Speichergrößen ausdrücklich zu setzen. Die Chart-Standards sind nur für eine grundlegende Evaluierung gedacht. diff --git a/content/de/installation/cloud-native/helm-chart/mtls.md b/content/de/installation/cloud-native/helm-chart/mtls.md index 5144b472e..c62b1aa29 100644 --- a/content/de/installation/cloud-native/helm-chart/mtls.md +++ b/content/de/installation/cloud-native/helm-chart/mtls.md @@ -1,28 +1,28 @@ --- title: mTLS -description: Configure mutual TLS between RustFS Pods deployed by the Helm chart. +description: Konfigurieren Sie gegenseitiges TLS zwischen RustFS-Pods, die das Helm-Chart bereitstellt. --- -The chart can enable mutual Transport Layer Security (mTLS) for RustFS Pod communication. When enabled, RustFS requires client certificates, uses HTTPS for generated peer URLs, and mounts server, client, and CA material into every Pod. +Das Chart kann gegenseitiges Transport Layer Security (mTLS) für die Kommunikation zwischen RustFS-Pods aktivieren. Wenn die Funktion aktiv ist, verlangt RustFS Client-Zertifikate, verwendet HTTPS für erzeugte Peer-URLs und hängt Server-, Client- und CA-Material in jeden Pod ein. -## Requirements +## Anforderungen -mTLS uses cert-manager `Issuer` and `Certificate` resources. Install cert-manager before enabling it and confirm that its CRDs are available: +mTLS verwendet die cert-manager-Ressourcen `Issuer` und `Certificate`. Installieren Sie cert-manager, bevor Sie mTLS aktivieren, und prüfen Sie, dass die CRDs verfügbar sind: ```bash kubectl get crd certificates.cert-manager.io issuers.cert-manager.io ``` -## 1. Use the chart-managed CA +## 1. Vom Chart verwaltete CA verwenden -Add the following setting to your existing values file: +Ergänzen Sie die folgende Einstellung in Ihrer vorhandenen Values-Datei: ```yaml title="values.yaml" mtls: enabled: true ``` -Upgrade the release: +Aktualisieren Sie das Release: ```bash helm upgrade rustfs ./helm/rustfs \ @@ -30,11 +30,11 @@ helm upgrade rustfs ./helm/rustfs \ -f values.yaml ``` -The chart creates a self-signed root CA, a namespace Issuer, and server and client Certificates. It mounts the resulting Secrets and configures RustFS with `RUSTFS_SERVER_MTLS_ENABLE=1` and `RUSTFS_TLS_PATH=/opt/tls`. Health probes also use the generated client certificate. +Das Chart erzeugt eine selbstsignierte Root-CA, einen Issuer im Namespace sowie Server- und Client-Certificates. Es hängt die resultierenden Secrets ein und konfiguriert RustFS mit `RUSTFS_SERVER_MTLS_ENABLE=1` und `RUSTFS_TLS_PATH=/opt/tls`. Die Integritäts-Probes verwenden ebenfalls das erzeugte Client-Zertifikat. -## 2. Use an existing Issuer +## 2. Vorhandenen Issuer verwenden -To use an Issuer or ClusterIssuer already managed by your platform, configure its reference: +Um einen Issuer oder ClusterIssuer zu verwenden, den Ihre Plattform bereits verwaltet, konfigurieren Sie dessen Referenz: ```yaml title="values.yaml" mtls: @@ -46,9 +46,9 @@ mtls: group: cert-manager.io ``` -The issuer must be ready and able to issue both server and client certificates in the `rustfs` namespace. Use `kind: Issuer` for a namespace-scoped issuer. +Der Issuer muss bereit sein und sowohl Server- als auch Client-Zertifikate im Namespace `rustfs` ausstellen können. Verwenden Sie `kind: Issuer` für einen auf den Namespace begrenzten Issuer. -## 3. Verify mTLS +## 3. mTLS prüfen ```bash kubectl -n rustfs get issuer,certificate,secret @@ -57,10 +57,10 @@ kubectl -n rustfs describe certificate rustfs-client-tls kubectl -n rustfs get pods ``` -For a release named `rustfs`, the generated certificate Secrets are `rustfs-server-tls` and `rustfs-client-tls`. +Für ein Release namens `rustfs` heißen die erzeugten Zertifikats-Secrets `rustfs-server-tls` und `rustfs-client-tls`. -:::warning[Plan external access] +:::warning[Externen Zugriff planen] -mTLS requires clients to present a trusted certificate. Validate how your Ingress controller or other external client presents that certificate before enabling mTLS on an existing deployment. +mTLS verlangt, dass Clients ein vertrauenswürdiges Zertifikat vorlegen. Prüfen Sie, wie Ihr Ingress-Controller oder ein anderer externer Client dieses Zertifikat vorlegt, bevor Sie mTLS für eine bestehende Bereitstellung aktivieren. -::: \ No newline at end of file +::: diff --git a/content/de/installation/cloud-native/index.md b/content/de/installation/cloud-native/index.md index 19175a9ec..47f5270c9 100644 --- a/content/de/installation/cloud-native/index.md +++ b/content/de/installation/cloud-native/index.md @@ -1,28 +1,28 @@ --- -title: "Kubernetes Installation (Helm)" -description: "Deploy RustFS on Kubernetes with the official Helm chart: standalone or distributed mode, storage sizing, probes, production hardening, and server-pool expansion." +title: "Kubernetes-Installation (Helm)" +description: "Stellen Sie RustFS mit dem offiziellen Helm-Chart auf Kubernetes bereit: Standalone- oder verteilter Modus, Speichergröße, Integritätsprüfungen, Härtung für den Produktivbetrieb und Erweiterung von Speicherpools." --- -RustFS ships an official Helm chart that deploys either a single-node instance (a `Deployment` with one PVC) or a distributed cluster (a `StatefulSet` with multiple pods and PVCs). This guide walks through installing the chart, choosing a deployment mode, sizing storage correctly, and the production options the chart provides. +RustFS liefert ein offizielles Helm-Chart, das entweder eine Einzelknoten-Instanz (ein `Deployment` mit einem PVC) oder einen verteilten Cluster (ein `StatefulSet` mit mehreren Pods und PVCs) bereitstellt. Diese Anleitung führt durch die Installation des Charts, die Wahl eines Bereitstellungsmodus, die korrekte Speicherdimensionierung und die Produktivoptionen, die das Chart bereitstellt. -**Prerequisites** +**Voraussetzungen** -- A Kubernetes cluster and `kubectl` access +- Ein Kubernetes-Cluster und Zugriff über `kubectl` - Helm 3 -- RustFS image version `>= 1.0.0-alpha.69` (the chart requirement) -- A StorageClass with a working provisioner — the chart defaults to [`local-path`](https://github.com/rancher/local-path-provisioner); set `storageclass.name` to use your own -- [`rc`](/operations/rc) installed on the administration host before using the server-pool commands in this guide +- RustFS-Image-Version `>= 1.0.0-alpha.69` (Anforderung des Charts) +- Eine StorageClass mit funktionierendem Provisioner. Das Chart verwendet standardmäßig [`local-path`](https://github.com/rancher/local-path-provisioner). Setzen Sie `storageclass.name`, um Ihre eigene StorageClass zu verwenden. +- [`rc`](/de/operations/rc) ist auf dem Verwaltungshost installiert, bevor Sie die Speicherpool-Befehle in dieser Anleitung verwenden -The chart lives in the RustFS source repository under `helm/rustfs`: +Das Chart liegt im RustFS-Quell-Repository unter `helm/rustfs`: ```bash git clone https://github.com/rustfs/rustfs.git cd rustfs/helm/rustfs ``` -## 1. Quick install +## 1. Schnellinstallation -Install into a dedicated namespace, setting your own credentials and a realistic data size: +Installieren Sie in einen eigenen Namespace und setzen Sie eigene Zugangsdaten sowie eine realistische Datengröße: ```bash helm install rustfs . \ @@ -33,19 +33,19 @@ helm install rustfs . \ --set storageclass.logStorageSize=1Gi ``` -:::note[The chart refuses default credentials] +:::note[Das Chart lehnt Standard-Zugangsdaten ab] -Rendering fails by default unless one of the following is true: +Das Rendern schlägt standardmäßig fehl, sofern nicht eine der folgenden Bedingungen zutrifft: -1. `secret.existingSecret` names a Kubernetes Secret you control, or -2. `secret.rustfs.access_key` and `secret.rustfs.secret_key` are **both** set to non-empty, non-default values, or -3. `secret.allowInsecureDefaults: true` is set (only for local development). +1. `secret.existingSecret` benennt ein Kubernetes-Secret, das Sie kontrollieren, oder +2. `secret.rustfs.access_key` und `secret.rustfs.secret_key` sind **beide** auf nicht leere Werte gesetzt, die nicht den Standardwerten entsprechen, oder +3. `secret.allowInsecureDefaults: true` ist gesetzt (nur für die lokale Entwicklung). -This prevents accidental deployment with the well-known default `rustfsadmin`/`rustfsadmin` credentials. Setting only one of the two keys is also rejected, so the chart never silently falls back to a default for the missing key. +So wird eine versehentliche Bereitstellung mit den allgemein bekannten Standard-Zugangsdaten `rustfsadmin`/`rustfsadmin` verhindert. Das Setzen nur eines der beiden Schlüssel wird ebenfalls abgelehnt. Das Chart fällt für den fehlenden Schlüssel nie stillschweigend auf einen Standardwert zurück. ::: -Watch the pods come up: +Beobachten Sie, wie die Pods starten: ```bash kubectl -n rustfs get pods -w @@ -59,17 +59,17 @@ rustfs-2 1/1 Running 0 2m27s rustfs-3 1/1 Running 0 2m27s ``` -## 2. Choose a deployment mode +## 2. Bereitstellungsmodus wählen -The chart supports two modes, selected via the `mode` values: +Das Chart unterstützt zwei Modi, die Sie über die `mode`-Values auswählen: -| Mode | Values | Workload | Layout | +| Modus | Werte | Arbeitslast | Aufbau | | --- | --- | --- | --- | -| Distributed (**default**) | `mode.distributed.enabled=true` | StatefulSet | `replicaCount` pods (`>= 2`, default `4`) × `drivesPerNode` data PVCs per pod (`>= 1`, inferred as `4` when `replicaCount: 4` or `1` otherwise; 16 drives by default) | -| Standalone | `mode.standalone.enabled=true`, `mode.distributed.enabled=false` | Deployment | 1 pod, 1 data PVC (single node single disk) | +| Verteilt (**Standard**) | `mode.distributed.enabled=true` | StatefulSet | `replicaCount` Pods (`>= 2`, Standard `4`) × `drivesPerNode` Daten-PVCs pro Pod (`>= 1`, abgeleitet als `4`, wenn `replicaCount: 4`, sonst als `1`; standardmäßig 16 Laufwerke) | +| Standalone | `mode.standalone.enabled=true`, `mode.distributed.enabled=false` | Deployment | 1 Pod, 1 Daten-PVC (ein Knoten, eine Festplatte) | -- **Standalone** matches single-node single-disk: no erasure-coding redundancy across nodes. Use it for development, testing, or small setups where the underlying storage provides its own durability. It can reuse existing PVCs via `mode.standalone.existingClaim.dataClaim` / `mode.standalone.existingClaim.logsClaim`. -- **Distributed** behaves like [multiple node multiple disk](../linux/multiple-node-multiple-disk.md): objects are erasure-coded across pods and PVCs. `replicaCount` sets the number of pods (`>= 2`) and `drivesPerNode` sets the number of data PVCs per pod (`>= 1`), giving `replicaCount * drivesPerNode` total drives. When `drivesPerNode` is left unset (`null`), the chart infers `4` data PVCs per pod when `replicaCount` is `4` (16 drives total) and `1` data PVC per pod for any other `replicaCount` (such as `replicaCount: 16` for 16 pods with 1 PVC each). Set both `replicaCount` and `drivesPerNode` explicitly (for example, `replicaCount: 4` and `drivesPerNode: 2` for 8 drives) to choose another layout. +- **Standalone** entspricht einem einzelnen Knoten mit einer Festplatte: Es gibt keine Erasure-Coding-Redundanz über Knoten hinweg. Verwenden Sie diesen Modus für Entwicklung, Tests oder kleine Umgebungen, in denen der zugrunde liegende Speicher selbst für Dauerhaftigkeit sorgt. Vorhandene PVCs lassen sich über `mode.standalone.existingClaim.dataClaim` und `mode.standalone.existingClaim.logsClaim` wiederverwenden. +- **Verteilt** verhält sich wie [mehrere Knoten, mehrere Festplatten](../linux/multiple-node-multiple-disk.md): Objekte werden per Erasure Coding über Pods und PVCs verteilt. `replicaCount` legt die Anzahl der Pods fest (`>= 2`) und `drivesPerNode` die Anzahl der Daten-PVCs pro Pod (`>= 1`). Daraus ergeben sich insgesamt `replicaCount * drivesPerNode` Laufwerke. Wenn `drivesPerNode` nicht gesetzt ist (`null`), leitet das Chart `4` Daten-PVCs pro Pod ab, wenn `replicaCount` den Wert `4` hat (insgesamt 16 Laufwerke), und `1` Daten-PVC pro Pod für jeden anderen Wert von `replicaCount` (etwa `replicaCount: 16` für 16 Pods mit je einem PVC). Setzen Sie `replicaCount` und `drivesPerNode` ausdrücklich (zum Beispiel `replicaCount: 4` und `drivesPerNode: 2` für 8 Laufwerke), um einen anderen Aufbau zu wählen. ```bash # Standalone mode @@ -80,9 +80,9 @@ helm install rustfs . -n rustfs --create-namespace \ --set secret.rustfs.secret_key= ``` -## 3. Storage sizing +## 3. Speicher dimensionieren -PVC sizes come from the `storageclass` block: +Die PVC-Größen stammen aus dem Block `storageclass`: ```yaml title="values-prod.yaml" storageclass: @@ -91,65 +91,65 @@ storageclass: logStorageSize: 256Mi # per logs PVC ``` -:::warning[The default PVC size is 256Mi — change it] +:::warning[Die Standard-PVC-Größe ist 256Mi — ändern Sie sie] -The chart's default size for the data and logs volumes is **256Mi**, which is only enough to verify the chart works. For any real workload set `storageclass.dataStorageSize` (for example `1Ti`) and `storageclass.logStorageSize` (for example `1Gi`) at install time. In distributed mode the data size applies to **each** data PVC (`replicaCount * drivesPerNode`, 16 PVCs by default). +Die Standardgröße des Charts für die Daten- und Protokoll-Volumes beträgt **256Mi**. Das reicht nur, um zu prüfen, ob das Chart funktioniert. Setzen Sie für jede reale Last bei der Installation `storageclass.dataStorageSize` (zum Beispiel `1Ti`) und `storageclass.logStorageSize` (zum Beispiel `1Gi`). Im verteilten Modus gilt die Datengröße für **jedes** Daten-PVC (`replicaCount * drivesPerNode`, standardmäßig 16 PVCs). ::: -Setting `config.rustfs.obs_log_directory` to `""` disables the log PVCs and mounts entirely. Custom PVC annotations go under `storageclass.pvcAnnotations.data` / `storageclass.pvcAnnotations.logs`. +Wenn Sie `config.rustfs.obs_log_directory` auf `""` setzen, werden die Protokoll-PVCs zusammen mit den zugehörigen Einhängungen deaktiviert. Eigene PVC-Annotationen tragen Sie unter `storageclass.pvcAnnotations.data` und `storageclass.pvcAnnotations.logs` ein. -## 4. Health probes +## 4. Integritätsprüfungen -The chart templates HTTP probes on the S3 port (9000) out of the box, matching the server's health endpoints: +Das Chart erzeugt standardmäßig HTTP-Probes auf dem S3-Port (9000), passend zu den Integritätsendpunkten des Servers: -- **Liveness**: `GET /health` (`livenessProbe.httpGet.path`), initial delay 30s, period 5s -- **Readiness**: `GET /health/ready` (`readinessProbe.httpGet.path`), initial delay 10s, period 5s +- **Liveness**: `GET /health` (`livenessProbe.httpGet.path`), anfängliche Verzögerung 30s, Intervall 5s +- **Readiness** (Bereitschaft): `GET /health/ready` (`readinessProbe.httpGet.path`), anfängliche Verzögerung 10s, Intervall 5s -A pod is only added to the Service endpoints once `/health/ready` returns `200`, which in distributed mode requires the storage quorum to be met. Thresholds and timings are tunable via the `livenessProbe.*` and `readinessProbe.*` values. +Ein Pod wird den Service-Endpunkten erst hinzugefügt, nachdem `/health/ready` den Status `200` zurückgibt. Im verteilten Modus setzt das voraus, dass das Speicher-Quorum erreicht ist. Schwellenwerte und Zeitintervalle lassen sich über die Values `livenessProbe.*` und `readinessProbe.*` anpassen. -## 5. Production hardening +## 5. Härtung für den Produktivbetrieb ### Pod Disruption Budget -Disabled by default. Enable it so voluntary evictions (node drains, cluster upgrades) never take more than one pod down at a time: +Standardmäßig deaktiviert. Aktivieren Sie es, damit freiwillige Evictions (Node-Drains, Cluster-Upgrades) nie mehr als einen Pod gleichzeitig entfernen: ```bash --set pdb.create=true # pdb.maxUnavailable defaults to 1 ``` -### Anti-affinity and topology spread +### Anti-Affinität und Topology Spread -`affinity.podAntiAffinity.enabled` defaults to `true` with `topologyKey: kubernetes.io/hostname`, spreading pods across distinct nodes. For zone-level spreading, enable `topologySpreadConstraints.enabled` and supply raw constraint entries under `topologySpreadConstraints.constraints` (applied to the distributed StatefulSet). +`affinity.podAntiAffinity.enabled` ist standardmäßig `true` mit `topologyKey: kubernetes.io/hostname` und verteilt Pods auf unterschiedliche Nodes. Für eine Verteilung auf Zonenebene aktivieren Sie `topologySpreadConstraints.enabled` und tragen die Constraint-Einträge unverarbeitet unter `topologySpreadConstraints.constraints` ein. Sie gelten für das verteilte StatefulSet. -### Inter-pod mTLS (cert-manager) +### mTLS zwischen Pods (cert-manager) -Set `mtls.enabled=true` to encrypt traffic between pods; the chart renders cert-manager `Issuer`/`Certificate` resources for a CA, server, and client certificates. To use an issuer you already operate, set `mtls.existingIssuerRef.enabled=true` with its `name`, `kind` (`Issuer` or `ClusterIssuer`), and `group`. +Setzen Sie `mtls.enabled=true`, um den Verkehr zwischen Pods zu verschlüsseln. Das Chart erzeugt cert-manager-Ressourcen vom Typ `Issuer` und `Certificate` für eine CA sowie für Server- und Client-Zertifikate. Um einen Issuer zu verwenden, den Sie bereits betreiben, setzen Sie `mtls.existingIssuerRef.enabled=true` zusammen mit `name`, `kind` (`Issuer` oder `ClusterIssuer`) und `group`. -### Ingress and Gateway API +### Ingress und Gateway API -Ingress is enabled by default (`ingress.enabled=true`) with `ingress.className: nginx`; set it to `traefik` if that is your controller — the chart applies the matching session-stickiness annotations for each. Set your domain via `ingress.hosts[0].host` (default `example.rustfs.com`). For HTTPS, enable `ingress.tls.enabled` and either pass the certificate with `--set-file ingress.tls.crt=./tls.crt --set-file ingress.tls.key=./tls.key`, point at an existing secret (`ingress.tls.existingSecret`), or let cert-manager issue one (`ingress.tls.certManager.enabled=true`). +Ingress ist standardmäßig aktiviert (`ingress.enabled=true`) mit `ingress.className: nginx`. Setzen Sie den Wert auf `traefik`, wenn das Ihr Controller ist. Das Chart setzt dann die passenden Annotations für Session-Stickiness. Legen Sie Ihre Domain über `ingress.hosts[0].host` fest (Standard `example.rustfs.com`). Aktivieren Sie für HTTPS `ingress.tls.enabled` und übergeben Sie das Zertifikat entweder mit `--set-file ingress.tls.crt=./tls.crt --set-file ingress.tls.key=./tls.key`, verweisen Sie auf ein vorhandenes Secret (`ingress.tls.existingSecret`) oder lassen Sie cert-manager eines ausstellen (`ingress.tls.certManager.enabled=true`). -The chart also has alpha [Gateway API](https://gateway-api.sigs.k8s.io/) support (`gatewayApi.enabled=true` together with `ingress.enabled=false`, Traefik gateway class), rendering `Gateway` and `HTTPRoute` resources. +Das Chart unterstützt außerdem die [Gateway API](https://gateway-api.sigs.k8s.io/) im Alpha-Status (`gatewayApi.enabled=true` zusammen mit `ingress.enabled=false`, Traefik-Gateway-Klasse) und erzeugt die Ressourcen `Gateway` und `HTTPRoute`. -## 6. Access RustFS +## 6. Auf RustFS zugreifen -Without an ingress, port-forward the Service: +Ohne Ingress leiten Sie den Service per Port-Forward weiter: ```bash kubectl -n rustfs port-forward svc/rustfs 9000:9000 9001:9001 ``` -- S3 API: `http://localhost:9000` -- Console: `http://localhost:9001` +- S3-API: `http://localhost:9000` +- Console (Weboberfläche): `http://localhost:9001` -Log in to the Console with the access key and secret key you set at install time. With ingress enabled, use your configured host instead (check `kubectl -n rustfs get ing`). The Service defaults to `ClusterIP`; `service.type` can be switched to `NodePort` (S3 on `service.endpoint.nodePort: 32000`, Console on `service.console.nodePort: 32001`) or `LoadBalancer`. +Melden Sie sich an der Console mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel an, die Sie bei der Installation gesetzt haben. Wenn Ingress aktiviert ist, verwenden Sie stattdessen den konfigurierten Host (prüfen Sie das mit `kubectl -n rustfs get ing`). Der Service ist standardmäßig `ClusterIP`. Über `service.type` können Sie auf `NodePort` wechseln (S3 über `service.endpoint.nodePort: 32000`, Console über `service.console.nodePort: 32001`) oder auf `LoadBalancer`. -## 7. Scaling out with server pools +## 7. Mit Speicherpools skalieren -In distributed mode the chart can run multiple **server pools** — independent StatefulSets whose drives together form one cluster. This is the chart-level equivalent of adding a Server Pool as described in [Pool Expansion](../../operations/scaling/storage-pool-expansion.md). +Im verteilten Modus kann das Chart mehrere **Speicherpools** betreiben: unabhängige StatefulSets, deren Laufwerke zusammen einen Cluster bilden. Das entspricht auf Chart-Ebene dem Hinzufügen eines Speicherpools, wie unter [Speicherpool-Erweiterung](../../operations/scaling/storage-pool-expansion.md) beschrieben. -To expand an existing deployment, enable pools and describe the current layout as pool 0 plus your new capacity: +Um eine bestehende Bereitstellung zu erweitern, aktivieren Sie Pools und beschreiben Sie das aktuelle Layout als Pool 0 plus die neue Kapazität: ```yaml title="values-prod.yaml (pools)" pools: @@ -162,27 +162,27 @@ pools: dataStorageSize: 10Gi ``` -Then apply with `helm upgrade`. Each entry may set `replicaCount` (`>= 2`) and/or a `storageclass` block; omitted fields inherit the top-level values. When top-level `drivesPerNode` is set explicitly, that drive count applies to every pool; when `drivesPerNode` is left unset (`null`), the chart infers the drive count per pool from that pool's `replicaCount` (`4` drives per pod when `replicaCount` is `4`, or `1` drive per pod otherwise). Additional pools render as `-pool` StatefulSets; all pools share the headless service, the main service, the configuration, and the credentials. +Wenden Sie die Änderung anschließend mit `helm upgrade` an. Jeder Eintrag kann `replicaCount` (`>= 2`), einen Block `storageclass` oder beides setzen. Ausgelassene Felder erben die Werte der obersten Ebene. Wenn `drivesPerNode` auf oberster Ebene ausdrücklich gesetzt ist, gilt diese Laufwerkszahl für jeden Pool. Wenn `drivesPerNode` nicht gesetzt ist (`null`), leitet das Chart die Laufwerkszahl pro Pool aus dem `replicaCount` dieses Pools ab (`4` Laufwerke pro Pod, wenn `replicaCount` den Wert `4` hat, sonst `1` Laufwerk pro Pod). Weitere Pools werden als StatefulSets `-pool` erzeugt. Alle Pools teilen sich den Headless Service, den Haupt-Service, die Konfiguration und die Zugangsdaten. -:::warning[Pools are append-only] +:::warning[Pools lassen sich nur anhängen] -The list index determines the StatefulSet name — never remove or reorder entries. Retire a pool with `rc admin decommission` before removing it from the list. +Der Listenindex bestimmt den Namen des StatefulSet. Entfernen Sie Einträge nicht und ändern Sie ihre Reihenfolge nicht. Nehmen Sie einen Pool mit `rc admin decommission` außer Betrieb, bevor Sie ihn aus der Liste entfernen. ::: -What to expect during the rollout, per the chart's documentation: +Was während des Rollouts zu erwarten ist, laut Dokumentation des Charts: -- **Crash/restart cycles are normal.** Pods restart until every pod of every pool is resolvable — the server refuses to start with unresolvable peers, so expect a few crash loops before the cluster converges. This is harmless. -- **Rebalance afterwards.** After the cluster converges, run `rc admin rebalance start ` to spread existing objects across the new pool. -- The PodDisruptionBudget spans all pools: with the default `pdb.maxUnavailable: 1`, at most one pod of the whole cluster may be evicted at a time. +- **Rechnen Sie mit Neustarts.** Pods starten neu, bis jeder Pod in jedem Pool auflösbar ist. Der Server startet nicht, wenn Peer-Adressen nicht aufgelöst werden können. Erwarten Sie daher einige Crash-Loops, bevor der Cluster konvergiert. Das ist unbedenklich. +- **Führen Sie anschließend ein Rebalancing aus.** Nachdem der Cluster konvergiert ist, führen Sie `rc admin rebalance start ` aus, um vorhandene Objekte auf den neuen Pool zu verteilen. +- Das PodDisruptionBudget umfasst alle Pools. Mit dem Standard `pdb.maxUnavailable: 1` darf höchstens ein Pod des gesamten Clusters gleichzeitig entfernt werden. :::note -`rc` is the RustFS command-line client. Use `rc admin pool list`, `expand`, `rebalance`, and `decommission` for the server-pool workflows described by the chart. +`rc` ist der Befehlszeilenclient von RustFS. Verwenden Sie `rc admin pool list`, `expand`, `rebalance` und `decommission` für die Speicherpool-Abläufe, die das Chart beschreibt. ::: -## 8. Uninstall +## 8. Deinstallation ```bash helm uninstall rustfs -n rustfs @@ -190,12 +190,12 @@ helm uninstall rustfs -n rustfs :::note -Helm does not delete PVCs created by StatefulSet volume claim templates. If you intend to discard the data, remove the PVCs explicitly (`kubectl -n rustfs delete pvc -l app.kubernetes.io/name=rustfs`) — otherwise a later reinstall with the same release name reattaches them. +Helm löscht keine PVCs, die aus Volume-Claim-Templates eines StatefulSet entstanden sind. Wenn Sie die Daten verwerfen möchten, entfernen Sie die PVCs ausdrücklich (`kubectl -n rustfs delete pvc -l app.kubernetes.io/name=rustfs`). Andernfalls hängt eine spätere Neuinstallation mit demselben Release-Namen sie wieder an. ::: -## Next steps +## Nächste Schritte -- [Pool Expansion](../../operations/scaling/storage-pool-expansion.md) — how Server Pool expansion works at the cluster level -- [Kubernetes Upgrade](../../operations/upgrade/kubernetes/index.md) — upgrade Helm- and Operator-managed deployments -- [TLS configuration](../../integration/tls-configured.md) — end-to-end TLS options +- [Speicherpool-Erweiterung](../../operations/scaling/storage-pool-expansion.md) — wie die Erweiterung von Speicherpools auf Cluster-Ebene funktioniert +- [Kubernetes-Upgrade](../../operations/upgrade/kubernetes/index.md) — Upgrade von Bereitstellungen, die Helm oder der Operator verwaltet +- [TLS-Konfiguration](../../integration/tls-configured.md) — durchgehende TLS-Optionen diff --git a/content/de/installation/cloud-native/meta.json b/content/de/installation/cloud-native/meta.json index 0cfcaba96..063810fde 100644 --- a/content/de/installation/cloud-native/meta.json +++ b/content/de/installation/cloud-native/meta.json @@ -1,5 +1,5 @@ { - "title": "Cloud-native", + "title": "Cloud-nativ", "pages": [ "helm-chart", "operator" diff --git a/content/de/installation/cloud-native/operator/index.md b/content/de/installation/cloud-native/operator/index.md index 68777f69c..dd3601d71 100644 --- a/content/de/installation/cloud-native/operator/index.md +++ b/content/de/installation/cloud-native/operator/index.md @@ -1,28 +1,28 @@ --- -title: Overview -description: Understand how RustFS Operator manages RustFS clusters on Kubernetes. +title: Überblick +description: Verstehen Sie, wie der RustFS Operator RustFS-Cluster auf Kubernetes verwaltet. --- -**RustFS Operator** applies the Kubernetes Operator pattern to RustFS clusters. Instead of creating StatefulSets, Services, PersistentVolumeClaims (PVCs), and configuration by hand, you declare the required storage cluster as a Kubernetes custom resource. The controller watches that resource and continuously reconciles the running cluster with the declared state. +**RustFS Operator** wendet das Kubernetes-Operator-Muster auf RustFS-Cluster an. Statt StatefulSets, Services, PersistentVolumeClaims (PVCs) und die Konfiguration von Hand anzulegen, deklarieren Sie den benötigten Speichercluster als Kubernetes-Custom-Resource. Der Controller beobachtet diese Ressource und gleicht den laufenden Cluster fortlaufend mit dem deklarierten Zustand ab. -The Operator installs two Custom Resource Definitions (CRDs): +Der Operator installiert zwei Custom Resource Definitions (CRDs): -- `Tenant` (`rustfs.com/v1alpha1`) represents one RustFS cluster. It defines storage pools, credentials, scheduling, Transport Layer Security (TLS), and Key Management Service (KMS) settings. -- `PolicyBinding` (`sts.rustfs.com/v1alpha1`) maps a Kubernetes ServiceAccount to RustFS policies when workloads request temporary credentials from the Operator Security Token Service (STS). +- `Tenant` (`rustfs.com/v1alpha1`) steht für einen RustFS-Cluster. Er definiert Speicherpools, Zugangsdaten, Scheduling, Transport Layer Security (TLS) und die Einstellungen des Key Management Service (KMS). +- `PolicyBinding` (`sts.rustfs.com/v1alpha1`) ordnet ein Kubernetes-ServiceAccount RustFS-Richtlinien zu, wenn Arbeitslasten temporäre Zugangsdaten vom Security Token Service (STS) des Operators anfordern. -One Operator can manage multiple Tenants across namespaces. Each Tenant has independent storage, credentials, S3 and Console services, and lifecycle. The Operator creates one StatefulSet for each pool, so you can add capacity by appending a pool without rebuilding the cluster. It also reports `Ready`, `Progressing`, or `Degraded` conditions and Kubernetes Events, and exposes health and metrics endpoints for cluster monitoring. +Ein Operator kann mehrere Tenants über Namespaces hinweg verwalten. Jeder Tenant hat eigenen Speicher, eigene Zugangsdaten, eigene S3- und Console-Services (Weboberfläche) sowie einen eigenen Lebenszyklus. Der Operator erzeugt pro Pool ein StatefulSet, sodass Sie Kapazität hinzufügen können, indem Sie einen Pool anhängen, ohne den Cluster neu aufzubauen. Er meldet außerdem die Conditions `Ready`, `Progressing` oder `Degraded` sowie Kubernetes-Events und stellt Endpunkte für Integrität und Metriken zur Cluster-Überwachung bereit. -The same API covers small test clusters and distributed deployments. Sensitive credentials and KMS material stay in Kubernetes Secrets, while version-controlled Tenant manifests hold only Secret references. This makes deployments repeatable, supports GitOps workflows, and keeps routine operations such as multi-tenant management, pool expansion, TLS, and encryption within Kubernetes-native tools. +Dieselbe API deckt kleine Testcluster und verteilte Bereitstellungen ab. Sensible Zugangsdaten und KMS-Material bleiben in Kubernetes-Secrets, während Tenant-Manifeste in der Versionsverwaltung nur Secret-Referenzen enthalten. Dadurch werden Bereitstellungen wiederholbar, GitOps-Abläufe werden unterstützt, und Routineaufgaben wie Mehrmandantenverwaltung, Speicherpool-Erweiterung, TLS und Verschlüsselung bleiben in Kubernetes-nativen Werkzeugen. -## Operator workflows +## Abläufe mit dem Operator -- [Install](./installation.md) covers requirements, Helm installation, Console access, and TLS configuration. -- [Multi-Tenant](./tenant.md) creates isolated RustFS clusters for different teams or workloads. -- [Pool Expansion](./pool-expansion.md) adds storage capacity by appending a pool to an existing Tenant. -- [KMS Integration](./kms.md) configures local or HashiCorp Vault key management for encrypted data. +- [Installation](./installation.md) behandelt Anforderungen, die Helm-Installation, den Zugriff auf die Console und die TLS-Konfiguration. +- [Mehrmandantenbetrieb](./tenant.md) erzeugt isolierte RustFS-Cluster für verschiedene Teams oder Arbeitslasten. +- [Speicherpool-Erweiterung](./pool-expansion.md) fügt Speicherkapazität hinzu, indem ein Pool an einen bestehenden Tenant angehängt wird. +- [KMS-Integration](./kms.md) konfiguriert die lokale oder die HashiCorp-Vault-Schlüsselverwaltung für verschlüsselte Daten. -:::warning[Pre-release software] +:::warning[Vorabversion] -RustFS Operator is currently `v0.1.0` pre-release software under active development. Validate upgrades and Tenant changes in a non-production cluster first. +RustFS Operator ist derzeit Vorabversionssoftware `v0.1.0` in aktiver Entwicklung. Prüfen Sie Upgrades und Tenant-Änderungen zuerst in einem nicht produktiven Cluster. -::: \ No newline at end of file +::: diff --git a/content/de/installation/cloud-native/operator/installation.md b/content/de/installation/cloud-native/operator/installation.md index 778625e77..84c3acdcc 100644 --- a/content/de/installation/cloud-native/operator/installation.md +++ b/content/de/installation/cloud-native/operator/installation.md @@ -1,29 +1,29 @@ --- -title: Install -description: Prepare Kubernetes, install RustFS Operator, and access its Console securely. +title: Installation +description: Bereiten Sie Kubernetes vor, installieren Sie den RustFS Operator und greifen Sie sicher auf seine Console zu. --- -This guide installs the Operator with Helm, verifies the deployment, and exposes the Operator Console locally or through HTTPS. +Diese Anleitung installiert den Operator mit Helm, prüft die Bereitstellung und macht die Operator-Console (Weboberfläche) lokal oder über HTTPS erreichbar. -## Requirements +## Anforderungen -| Component | Requirement | +| Komponente | Anforderung | |-----------|-------------| -| Kubernetes | `v1.30` or later | -| Helm | `v3.0` or later | -| kubectl | Compatible with the Kubernetes cluster | -| StorageClass | Dynamic PVC provisioning for Tenant storage | +| Kubernetes | `v1.30` oder neuer | +| Helm | `v3.0` oder neuer | +| kubectl | Kompatibel mit dem Kubernetes-Cluster | +| StorageClass | Dynamische PVC-Bereitstellung für Tenant-Speicher | -Your account must be able to create CRDs, cluster RBAC, Deployments, and Services. Confirm the target cluster before installation: +Ihr Konto muss CRDs, Cluster-RBAC, Deployments und Services anlegen können. Bestätigen Sie den Zielcluster vor der Installation: ```bash kubectl config current-context kubectl get storageclass ``` -## 1. Install the Operator +## 1. Operator installieren -The Helm chart is stored in the Operator repository: +Das Helm-Chart liegt im Operator-Repository: ```bash git clone https://github.com/rustfs/operator.git @@ -34,7 +34,7 @@ helm upgrade --install rustfs-operator deploy/rustfs-operator/ \ --create-namespace ``` -Common settings belong in a values file: +Übliche Einstellungen gehören in eine Values-Datei: ```yaml title="values.yaml" operator: @@ -50,9 +50,9 @@ console: type: ClusterIP ``` -Apply the file with `-f values.yaml`. The chart generates `OPERATOR_*` variables from these values; do not duplicate them under `operator.env`. +Wenden Sie die Datei mit `-f values.yaml` an. Das Chart erzeugt aus diesen Werten die Variablen `OPERATOR_*`. Duplizieren Sie sie nicht unter `operator.env`. -## 2. Verify the installation +## 2. Installation prüfen ```bash kubectl -n rustfs-system get pods,services @@ -61,32 +61,32 @@ kubectl -n rustfs-system rollout status deployment/rustfs-operator kubectl -n rustfs-system rollout status deployment/rustfs-operator-console ``` -## 3. Access the Operator Console +## 3. Auf die Operator-Console zugreifen -The Console listens on port `9090`. Generate a short-lived login token: +Die Console lauscht auf Port `9090`. Erzeugen Sie ein kurzlebiges Anmelde-Token: ```bash kubectl -n rustfs-system create token rustfs-operator-console --duration=24h ``` -Forward the Console service to your workstation: +Leiten Sie den Console-Service auf Ihre Arbeitsstation weiter: ```bash kubectl -n rustfs-system port-forward \ svc/rustfs-operator-console 19090:9090 ``` -Open `http://127.0.0.1:19090` and paste the token into the login form. The Helm installation notes print the exact ServiceAccount and Service names when release names or namespaces differ. +Öffnen Sie `http://127.0.0.1:19090` und fügen Sie das Token in das Anmeldeformular ein. Die Helm-Installationshinweise geben die genauen Namen von ServiceAccount und Service aus, wenn Release-Namen oder Namespaces abweichen. -:::note[Local HTTP access] +:::note[Lokaler HTTP-Zugriff] -If your browser does not retain the login over HTTP, set `CONSOLE_COOKIE_SECURE=false` under `console.env` for local testing only. Keep secure cookies enabled for HTTPS. +Wenn Ihr Browser die Anmeldung über HTTP nicht beibehält, setzen Sie `CONSOLE_COOKIE_SECURE=false` unter `console.env` ausschließlich für lokale Tests. Lassen Sie sichere Cookies für HTTPS aktiviert. ::: -## 4. Configure Console TLS +## 4. TLS der Console konfigurieren -Use one HTTPS hostname for both the Console UI and `/api/v1`. Create a TLS Secret, or let cert-manager create it, then enable Ingress: +Verwenden Sie einen HTTPS-Hostnamen sowohl für die Console-Oberfläche als auch für `/api/v1`. Legen Sie ein TLS-Secret an oder lassen Sie es von cert-manager anlegen und aktivieren Sie anschließend Ingress: ```yaml title="values.yaml" console: @@ -106,7 +106,7 @@ console: - console.example.com ``` -Upgrade the release with the values file: +Aktualisieren Sie das Release mit der Values-Datei: ```bash helm upgrade rustfs-operator deploy/rustfs-operator/ \ @@ -114,6 +114,6 @@ helm upgrade rustfs-operator deploy/rustfs-operator/ \ -f values.yaml ``` -Replace the Ingress class, issuer, and hostname for your environment. If cert-manager is not installed, create the `console-tls` Secret with your certificate and private key before the upgrade. +Ersetzen Sie Ingress-Klasse, Issuer und Hostname für Ihre Umgebung. Wenn cert-manager nicht installiert ist, legen Sie das Secret `console-tls` mit Ihrem Zertifikat und Ihrem privaten Schlüssel an, bevor Sie das Upgrade ausführen. -Next, [create a Tenant](./tenant.md). \ No newline at end of file +Als Nächstes [legen Sie einen Tenant an](./tenant.md). diff --git a/content/de/installation/cloud-native/operator/kms.md b/content/de/installation/cloud-native/operator/kms.md index 60c89950f..38ff0a0b3 100644 --- a/content/de/installation/cloud-native/operator/kms.md +++ b/content/de/installation/cloud-native/operator/kms.md @@ -1,17 +1,17 @@ --- -title: KMS Integration -description: Configure local or HashiCorp Vault key management for a RustFS Tenant through the Operator encryption API. +title: KMS-Integration +description: Konfigurieren Sie die lokale oder die HashiCorp-Vault-Schlüsselverwaltung für einen RustFS-Tenant über die Verschlüsselungs-API des Operators. --- -Configure Key Management Service (KMS) integration through `spec.encryption`. Do not add `RUSTFS_KMS_*` variables to `spec.env`; the Operator generates them from the structured Tenant configuration and Secret references. +Konfigurieren Sie die Integration des Key Management Service (KMS) über `spec.encryption`. Fügen Sie keine Variablen `RUSTFS_KMS_*` zu `spec.env` hinzu. Der Operator erzeugt sie aus der strukturierten Tenant-Konfiguration und den Secret-Referenzen. -## Choose a backend +## Backend wählen -Use `local` only for a single-server Tenant. Use `vault` for distributed deployments where every Tenant Pod can reach HashiCorp Vault. +Verwenden Sie `local` nur für einen Tenant mit einem einzelnen Server. Verwenden Sie `vault` für verteilte Bereitstellungen, in denen jeder Tenant-Pod HashiCorp Vault erreichen kann. -## Local KMS +## Lokales KMS -Create a master key Secret: +Legen Sie ein Secret für den Hauptschlüssel an: ```yaml title="local-kms-secret.yaml" apiVersion: v1 @@ -24,7 +24,7 @@ stringData: local-master-key: "replace-with-a-random-master-key" ``` -Add the encryption block to the existing Tenant manifest: +Ergänzen Sie den Verschlüsselungsblock im vorhandenen Tenant-Manifest: ```yaml title="tenant.yaml" spec: @@ -39,11 +39,11 @@ spec: defaultKeyId: tenant-default ``` -The key directory must be inside a mounted data path so it survives Pod replacement. +Das Schlüsselverzeichnis muss in einem eingehängten Datenpfad liegen, damit es einen Pod-Ersatz übersteht. -## HashiCorp Vault KMS +## HashiCorp Vault als KMS -Create a Secret containing a Vault token: +Legen Sie ein Secret mit einem Vault-Token an: ```yaml title="vault-kms-secret.yaml" apiVersion: v1 @@ -56,7 +56,7 @@ stringData: vault-token: "replace-with-vault-token" ``` -Add the Vault configuration to the existing Tenant manifest: +Ergänzen Sie die Vault-Konfiguration im vorhandenen Tenant-Manifest: ```yaml title="tenant.yaml" spec: @@ -70,9 +70,9 @@ spec: defaultKeyId: tenant-default ``` -Every Tenant Pod must be able to resolve and connect to the Vault endpoint and trust its certificate. +Jeder Tenant-Pod muss den Vault-Endpunkt auflösen und erreichen können und seinem Zertifikat vertrauen. -## Apply the configuration +## Konfiguration anwenden ```bash kubectl apply -f local-kms-secret.yaml @@ -80,10 +80,10 @@ kubectl apply -f tenant.yaml kubectl -n storage-a describe tenant tenant-a ``` -For Vault, apply `vault-kms-secret.yaml` before `tenant.yaml`. Changing encryption settings rolls the affected StatefulSets. +Bei Vault wenden Sie `vault-kms-secret.yaml` vor `tenant.yaml` an. Eine Änderung der Verschlüsselungseinstellungen führt ein Rolling Update der betroffenen StatefulSets aus. -:::warning[Protect encryption keys] +:::warning[Verschlüsselungsschlüssel schützen] -Back up key material and test recovery before storing production data. Losing the local master key or Vault keys can make encrypted objects unrecoverable. +Sichern Sie das Schlüsselmaterial und prüfen Sie die Wiederherstellung, bevor Sie Produktivdaten speichern. Der Verlust des lokalen Hauptschlüssels oder der Vault-Schlüssel kann dazu führen, dass sich verschlüsselte Objekte nicht wiederherstellen lassen. -::: \ No newline at end of file +::: diff --git a/content/de/installation/cloud-native/operator/pool-expansion.md b/content/de/installation/cloud-native/operator/pool-expansion.md index 482c99b54..707263b17 100644 --- a/content/de/installation/cloud-native/operator/pool-expansion.md +++ b/content/de/installation/cloud-native/operator/pool-expansion.md @@ -1,28 +1,28 @@ --- -title: Pool Expansion -description: Add storage capacity to a RustFS Tenant by appending a storage pool. +title: Speicherpool-Erweiterung +description: Erweitern Sie die Speicherkapazität eines RustFS-Tenants, indem Sie einen Speicherpool anhängen. --- -All pools in a Tenant form one RustFS cluster. Add capacity by appending a new pool to `spec.pools`; do not change the shape of an existing pool. +Alle Pools eines Tenants bilden einen RustFS-Cluster. Erweitern Sie die Kapazität, indem Sie einen neuen Pool an `spec.pools` anhängen. Ändern Sie die Form eines bestehenden Pools nicht. -:::warning[Existing pools are immutable] +:::warning[Bestehende Pools sind unveränderlich] -Do not change `servers` or `persistence.volumesPerServer` on an existing pool. The Operator creates an immutable StatefulSet for each pool. +Ändern Sie `servers` oder `persistence.volumesPerServer` eines bestehenden Pools nicht. Der Operator erzeugt für jeden Pool ein unveränderliches StatefulSet. ::: -## 1. Check the Tenant +## 1. Tenant prüfen ```bash kubectl -n storage-a get tenant tenant-a kubectl -n storage-a get pods,pvc -l rustfs.tenant=tenant-a ``` -Confirm that the Tenant is `Ready` and the cluster has enough compute and storage capacity. +Prüfen Sie, dass der Tenant `Ready` ist und der Cluster genug Rechen- und Speicherkapazität hat. -## 2. Add a pool +## 2. Pool hinzufügen -Append the following entry to the existing `spec.pools` list in `tenant.yaml`. Keep all existing entries unchanged. +Hängen Sie den folgenden Eintrag an die bestehende Liste `spec.pools` in `tenant.yaml` an. Lassen Sie alle vorhandenen Einträge unverändert. ```yaml title="tenant.yaml" - name: pool-1 @@ -38,13 +38,13 @@ Append the following entry to the existing `spec.pools` list in `tenant.yaml`. K storage: 100Gi ``` -This pool creates four PVCs: two servers multiplied by two volumes per server. Apply the complete Tenant manifest: +Dieser Pool erzeugt vier PVCs: zwei Server multipliziert mit zwei Volumes pro Server. Wenden Sie das vollständige Tenant-Manifest an: ```bash kubectl apply -f tenant.yaml ``` -## 3. Watch the expansion +## 3. Erweiterung beobachten ```bash kubectl -n storage-a get tenant tenant-a -w @@ -52,4 +52,4 @@ kubectl -n storage-a get pods,pvc \ -l rustfs.pool=pool-1 ``` -Wait for the Tenant to return to `Ready` before making another topology change. Increasing an existing PVC size is a separate Kubernetes storage operation and depends on the StorageClass. \ No newline at end of file +Warten Sie, bis der Tenant wieder `Ready` ist, bevor Sie eine weitere Topologieänderung vornehmen. Die Vergrößerung eines bestehenden PVC ist ein eigener Kubernetes-Speichervorgang und hängt von der StorageClass ab. diff --git a/content/de/installation/cloud-native/operator/tenant.md b/content/de/installation/cloud-native/operator/tenant.md index 08bec042f..9084b337f 100644 --- a/content/de/installation/cloud-native/operator/tenant.md +++ b/content/de/installation/cloud-native/operator/tenant.md @@ -1,13 +1,13 @@ --- -title: Multi-Tenant -description: Create isolated RustFS Tenants and access their S3 API and Console services. +title: Mehrmandantenbetrieb +description: Legen Sie isolierte RustFS-Tenants an und greifen Sie auf deren S3-API und Console-Services zu. --- -A `Tenant` represents one independent RustFS cluster. Use a separate namespace, credentials Secret, and Tenant resource for each team or workload. +Ein `Tenant` steht für einen unabhängigen RustFS-Cluster. Verwenden Sie für jedes Team oder jede Arbeitslast einen eigenen Namespace, ein eigenes Zugangsdaten-Secret und eine eigene Tenant-Ressource. -## 1. Create a namespace and credentials +## 1. Namespace und Zugangsdaten anlegen -Create the Secret directly so credentials are not stored in a manifest: +Legen Sie das Secret direkt an, damit die Zugangsdaten nicht in einem Manifest gespeichert werden: ```bash kubectl create namespace storage-a @@ -16,9 +16,9 @@ kubectl -n storage-a create secret generic rustfs-tenant-creds \ --from-literal=secretkey='' ``` -## 2. Define the Tenant +## 2. Tenant definieren -This development example creates one RustFS Pod and one `10Gi` PVC. Replace `standard` with a StorageClass in your cluster. +Dieses Entwicklungsbeispiel erzeugt einen RustFS-Pod und ein PVC mit `10Gi`. Ersetzen Sie `standard` durch eine StorageClass in Ihrem Cluster. ```yaml title="tenant.yaml" apiVersion: rustfs.com/v1alpha1 @@ -44,7 +44,7 @@ spec: storage: 10Gi ``` -## 3. Apply and verify +## 3. Anwenden und prüfen ```bash kubectl apply -f tenant.yaml @@ -52,23 +52,23 @@ kubectl -n storage-a get tenant,pods,pvc,svc kubectl -n storage-a describe tenant tenant-a ``` -## 4. Access RustFS +## 4. Auf RustFS zugreifen ```bash kubectl -n storage-a port-forward svc/tenant-a-io 9000:9000 kubectl -n storage-a port-forward svc/tenant-a-console 9001:9001 ``` -Run the commands in separate terminals. Use `http://localhost:9000` as the S3 endpoint and open `http://localhost:9001` for the Tenant Console. +Führen Sie die Befehle in getrennten Terminals aus. Verwenden Sie `http://localhost:9000` als S3-Endpunkt und öffnen Sie `http://localhost:9001` für die Tenant-Console (Weboberfläche). -To add another Tenant, repeat the process with a different namespace, Secret, and Tenant name. List all managed Tenants with: +Um einen weiteren Tenant hinzuzufügen, wiederholen Sie den Vorgang mit einem anderen Namespace, Secret und Tenant-Namen. Listen Sie alle verwalteten Tenants so auf: ```bash kubectl get tenants --all-namespaces ``` -:::warning[Production topology] +:::warning[Produktivtopologie] -The one-server example is for evaluation. Production Tenants need a distributed pool layout, resource requests, scheduling constraints, and an immutable image reference. +Das Beispiel mit einem Server dient der Evaluierung. Produktive Tenants benötigen ein verteiltes Pool-Layout, Ressourcenanforderungen, Scheduling-Einschränkungen und eine unveränderliche Image-Referenz. -::: \ No newline at end of file +::: diff --git a/content/de/installation/container/docker.md b/content/de/installation/container/docker.md index c88d61007..fbffd52fe 100644 --- a/content/de/installation/container/docker.md +++ b/content/de/installation/container/docker.md @@ -1,33 +1,33 @@ --- title: "Docker" -description: "Run RustFS with Docker: single-node setup, host-directory permissions, Docker Compose, TLS, and multi-node deployment." +description: "Betreiben Sie RustFS mit Docker: Einrichtung auf einem Knoten, Berechtigungen der Host-Verzeichnisse, Docker Compose, TLS und eine Bereitstellung auf mehreren Knoten." --- -This page covers running the official RustFS image with Docker: a single-node instance with persistent storage, host-directory permissions for the non-root container user, Docker Compose with optional observability services, TLS, and a multi-node deployment. You need a working Docker Engine and permission to run containers. +Diese Seite beschreibt, wie Sie das offizielle RustFS-Image mit Docker betreiben: eine Instanz auf einem Knoten mit persistentem Speicher, Verzeichnisberechtigungen auf dem Host für den Container-Benutzer ohne Root-Rechte, Docker Compose mit optionalen Observability-Diensten, TLS und eine Bereitstellung auf mehreren Knoten. Sie benötigen eine funktionsfähige Docker Engine und die Berechtigung, Container auszuführen. -## 1. Prerequisites +## 1. Voraussetzungen -* Docker Engine (≥ 20.10) installed and able to pull images and run containers normally -* Host ports 9000 (S3 API) and 9001 (Console) available, or consistent with your custom ports -* If you bind-mount a host directory, the directory owner must match the container user — see [Bind-mount a host directory](#bind-mount-a-host-directory) +* Docker Engine (≥ 20.10) ist installiert, und Sie können Images abrufen und Container ausführen +* Die Host-Ports 9000 (S3-API) und 9001 (Console, Weboberfläche) sind frei, oder Sie verwenden die Ports, die Sie vorgesehen haben +* Wenn Sie ein Host-Verzeichnis per Bind-Mount einhängen, muss der Eigentümer des Verzeichnisses dem Container-Benutzer entsprechen — siehe [Host-Verzeichnis per Bind-Mount einbinden](#5-host-verzeichnis-per-bind-mount-einbinden) -## 2. Pull the image +## 2. Image abrufen ```bash docker pull rustfs/rustfs:latest ``` -## 3. Create persistent storage +## 3. Persistenten Speicher anlegen -Create a named volume so object data remains available when you replace the container: +Legen Sie ein benanntes Volume an, damit die Objektdaten verfügbar bleiben, wenn Sie den Container ersetzen: ```bash docker volume create rustfs-data ``` -## 4. Start RustFS +## 4. RustFS starten -Replace the credential placeholders before running the container: +Ersetzen Sie die Platzhalter für die Zugangsdaten, bevor Sie den Container starten: ```bash docker run -d \ @@ -47,15 +47,15 @@ docker run -d \ /data ``` -:::warning[Set credentials when creating the container] +:::warning[Zugangsdaten beim Erstellen des Containers festlegen] -Set unique `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` environment variables before exposing RustFS to a network. Do not use the well-known `rustfsadmin` value for either credential. If the container was started without custom credentials, stop and recreate it with both `-e` options shown above; the `rustfs-data` volume remains intact. +Legen Sie eindeutige Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` fest, bevor Sie RustFS in einem Netzwerk erreichbar machen. Verwenden Sie den allgemein bekannten Wert `rustfsadmin` weder als Zugriffsschlüssel noch als geheimen Zugriffsschlüssel. Wenn der Container ohne eigene Zugangsdaten gestartet wurde, beenden Sie ihn und erstellen Sie ihn mit beiden oben gezeigten `-e`-Optionen neu. Das Volume `rustfs-data` bleibt dabei erhalten. ::: -### Environment variables or command-line flags +### Umgebungsvariablen oder Kommandozeilenoptionen -The example above configures RustFS with environment variables. You can pass the same settings as command-line flags instead; when both are present, command-line flags win: +Das Beispiel oben konfiguriert RustFS über Umgebungsvariablen. Dieselben Einstellungen können Sie stattdessen als Kommandozeilenoptionen übergeben. Wenn beides gesetzt ist, haben die Kommandozeilenoptionen Vorrang: ```bash docker run -d \ @@ -71,40 +71,40 @@ docker run -d \ /data ``` -## 5. Bind-mount a host directory +## 5. Host-Verzeichnis per Bind-Mount einbinden -The named volume above needs no extra setup. If you mount a host directory instead (`-v /path/on/host:/data`), keep in mind that the container runs as non-root user `rustfs` with id `10001`. Make the host directory owned by `10001`, otherwise you will encounter permission denied errors: +Das benannte Volume oben braucht keine weitere Vorbereitung. Wenn Sie stattdessen ein Host-Verzeichnis einhängen (`-v /path/on/host:/data`), läuft der Container als Benutzer `rustfs` ohne Root-Rechte mit der ID `10001`. Der Eigentümer des Host-Verzeichnisses muss `10001` sein, sonst treten Fehler `permission denied` auf: ```bash chown -R 10001:10001 /path/to/host_directory ``` -## 6. Verify the deployment +## 6. Bereitstellung prüfen -Check the container and the S3 API health endpoint: +Prüfen Sie den Container und den Integritätsendpunkt der S3-API: ```bash docker ps --filter name=rustfs curl --fail http://localhost:9000/health ``` -The S3 API is available at `http://localhost:9000`, and the Console is available at `http://localhost:9001`. +Die S3-API ist unter `http://localhost:9000` erreichbar, die Console unter `http://localhost:9001`. ## Docker Compose -The RustFS repository ships a [`docker-compose.yml`](https://github.com/rustfs/rustfs/blob/main/docker-compose.yml) that includes `grafana`, `prometheus`, `otel-collector`, and `jaeger` services, mainly for observability. To deploy RustFS together with these services, clone the [RustFS code repository](https://github.com/rustfs/rustfs) locally: +Das RustFS-Repository enthält eine [`docker-compose.yml`](https://github.com/rustfs/rustfs/blob/main/docker-compose.yml) mit den Diensten `grafana`, `prometheus`, `otel-collector` und `jaeger`, vor allem für Observability. Um RustFS zusammen mit diesen Diensten bereitzustellen, klonen Sie das [RustFS-Quellcode-Repository](https://github.com/rustfs/rustfs) lokal: ```bash git clone https://github.com/rustfs/rustfs.git ``` -Run the command from the repository root: +Führen Sie den Befehl im Wurzelverzeichnis des Repositorys aus: ```bash docker compose --profile observability up -d ``` -The compose file uses an initialization container to grant the correct access rights to `rustfs`: the `rustfs_perms` service below changes the ownership of the mounted volumes to `10001` before `rustfs` starts, using `depends_on` to wait for it to complete. To keep logs persistent and accessible, the host log directory is mapped to the container's `/var/log/rustfs/` path: +Die Compose-Datei verwendet einen Initialisierungscontainer, der `rustfs` die richtigen Zugriffsrechte einräumt. Der Dienst `rustfs_perms` setzt den Eigentümer der eingehängten Volumes auf `10001`, bevor `rustfs` startet. Über `depends_on` wartet `rustfs`, bis dieser Dienst abgeschlossen ist. Damit die Logs dauerhaft gespeichert und zugänglich bleiben, wird das Logverzeichnis auf dem Host auf den Pfad `/var/log/rustfs/` im Container abgebildet: ```yaml title="docker-compose.yml" services: @@ -134,21 +134,21 @@ The compose file uses an initialization container to grant the correct access ri # ... other configurations ``` -If you only want RustFS without Grafana, Prometheus, and the other observability services, start just the `rustfs` service (the compose file marks the collector dependency as optional): +Wenn Sie nur RustFS ohne Grafana, Prometheus und die übrigen Observability-Dienste wollen, starten Sie nur den Dienst `rustfs` (die Compose-Datei kennzeichnet die Abhängigkeit vom Collector als optional): ```bash docker compose -f docker-compose.yml up -d rustfs ``` -This starts only the `rustfs-server` container. Whether you start only `rustfs-server` or the full stack, the S3 API is served at `http://localhost:9000`, and the RustFS Console is at `http://localhost:9001`. Open the Console in a browser and log in with the access key and secret key you configured above. Generate a strong secret with, for example, `openssl rand -base64 24`, and never ship the placeholder values to production. +Damit startet nur der Container `rustfs-server`. Egal, ob Sie nur `rustfs-server` oder alle Dienste starten: Die S3-API ist unter `http://localhost:9000` erreichbar, die RustFS Console unter `http://localhost:9001`. Öffnen Sie die Console im Browser und melden Sie sich mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel an, die Sie oben festgelegt haben. Erzeugen Sie ein starkes Geheimnis, zum Beispiel mit `openssl rand -base64 24`, und übernehmen Sie die Platzhalterwerte nicht in die Produktion. -For Docker Compose, define unique `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` values in the `rustfs` service environment or in the environment file used for variable substitution, then recreate the service with `docker compose up -d rustfs`. +Legen Sie für Docker Compose eindeutige Werte für `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` in der Umgebung des Dienstes `rustfs` oder in der Umgebungsdatei für die Variablenersetzung fest. Erstellen Sie den Dienst anschließend mit `docker compose up -d rustfs` neu. -## Multi-node deployment +## Bereitstellung auf mehreren Knoten -Docker's default bridge networking does not support multi-node deployments. Use `--network host` so each container can communicate directly with other nodes. +Das Standard-Bridge-Netzwerk von Docker unterstützt keine Bereitstellungen auf mehreren Knoten. Verwenden Sie `--network host`, damit jeder Container direkt mit den anderen Knoten kommunizieren kann. -Run the following on **each node**: +Führen Sie Folgendes auf **jedem Knoten** aus: ```bash docker run -d \ @@ -166,7 +166,7 @@ docker run -d \ rustfs/rustfs:latest ``` -Add the entries to `/etc/hosts` on **every** node: +Tragen Sie die Einträge auf **jedem** Knoten in `/etc/hosts` ein: ```ini title="/etc/hosts" 192.168.1.1 node1 @@ -175,21 +175,21 @@ Add the entries to `/etc/hosts` on **every** node: 192.168.1.4 node4 ``` -## TLS configuration +## TLS-Konfiguration -If [using TLS](../../integration/tls-configured.md), mount the certificate directory and point RustFS at it: +Wenn Sie [TLS verwenden](../../integration/tls-configured.md), hängen Sie das Zertifikatsverzeichnis ein und verweisen Sie RustFS darauf: ```bash -v /path/to/certs:/certs \ -e RUSTFS_TLS_PATH=/certs \ ``` -## Before production +## Vor dem Produktivbetrieb -Work through the [Pre-Installation Checklists](../requirement/checklists/index.md) — hardware, network, software, and security — before deploying to production. Use a multi-node deployment architecture, [enable TLS encrypted communication](../../integration/tls-configured.md), configure a log rotation strategy, and set up a regular backup strategy. +Arbeiten Sie die [Checklisten vor der Installation](../requirement/checklists/index.md) durch — Hardware, Netzwerk, Software und Sicherheit —, bevor Sie in der Produktion bereitstellen. Verwenden Sie eine Bereitstellung auf mehreren Knoten, [aktivieren Sie TLS](../../integration/tls-configured.md), konfigurieren Sie die Logrotation und planen Sie regelmäßige Sicherungen. -## Next steps +## Nächste Schritte -- [RustFS Console](/administration/console) -- [Configure an S3 client](../../developer/examples/aws-cli.md) -- [TLS configuration](../../integration/tls-configured.md) +- [RustFS Console](/de/administration/console) +- [S3-Client konfigurieren](../../developer/examples/aws-cli.md) +- [TLS-Konfiguration](../../integration/tls-configured.md) diff --git a/content/de/installation/container/index.md b/content/de/installation/container/index.md index 4ee47b47d..d017f9f9d 100644 --- a/content/de/installation/container/index.md +++ b/content/de/installation/container/index.md @@ -1,20 +1,20 @@ --- title: "Container" -description: "Run the official RustFS container image with Docker or Podman." +description: "Betreiben Sie das offizielle Container-Image von RustFS mit Docker oder Podman." --- -RustFS is a high-performance, S3-compatible open-source distributed object storage system. In single-node single-disk (SNSD) deployment mode, the backend uses zero erasure coding without additional data redundancy, which makes it suitable for local testing and small-scale scenarios. The official RustFS image packages the RustFS binary and its runtime environment into a container, so you can start a service with a single command and persistent storage. +RustFS ist ein quelloffenes, S3-kompatibles System für verteilten Objektspeicher. Im Modus mit einem einzelnen Knoten und einem Datenträger (SNSD) verwendet RustFS kein Erasure Coding und speichert keine redundanten Daten. Dieser Modus eignet sich daher nur für lokale Tests und kleine Arbeitslasten. Das offizielle RustFS-Image packt die RustFS-Binärdatei und ihre Laufzeitumgebung in einen Container, sodass Sie RustFS mit persistentem Speicher durch einen einzigen Befehl starten. -The container runs as non-root user `rustfs` with id `10001`, so a bind-mounted host directory must be owned by `10001` to avoid permission denied errors. +Der Container läuft als Benutzer `rustfs` ohne Root-Rechte mit der ID `10001`. Ein per Bind-Mount eingehängtes Host-Verzeichnis muss daher `10001` gehören, sonst treten Fehler `permission denied` auf. -## Container runtimes +## Container-Laufzeiten -- [Docker](./docker.md): run a single-node instance with persistent storage, then extend it with Docker Compose, TLS, and multi-node networking. -- [Podman](./podman.md): run the same image in a daemonless workflow. +- [Docker](./docker.md): Betreiben Sie eine Instanz auf einem Knoten mit persistentem Speicher und erweitern Sie sie anschließend um Docker Compose, TLS und Netzwerke für mehrere Knoten. +- [Podman](./podman.md): Betreiben Sie dasselbe Image in einem Ablauf ohne Daemon. -:::note[Directory permissions] +:::note[Verzeichnisberechtigungen] -If you mount a host directory into the container with `-v`, make sure the owner of the host directory is `10001`: +Wenn Sie ein Host-Verzeichnis mit `-v` in den Container einhängen, muss `10001` der Eigentümer des Host-Verzeichnisses sein: ```bash chown -R 10001:10001 /path/to/host_directory @@ -22,4 +22,4 @@ chown -R 10001:10001 /path/to/host_directory ::: -For Kubernetes deployments, see the [Helm chart](/installation/cloud-native/helm-chart) or the [Operator](/installation/cloud-native/operator) instead. +Für Kubernetes-Bereitstellungen verwenden Sie stattdessen das [Helm-Chart](/de/installation/cloud-native/helm-chart) oder den [Operator](/de/installation/cloud-native/operator). diff --git a/content/de/installation/container/podman.md b/content/de/installation/container/podman.md index 9ce2a6fcd..e2d171a3b 100644 --- a/content/de/installation/container/podman.md +++ b/content/de/installation/container/podman.md @@ -1,27 +1,27 @@ --- title: "Podman" -description: "Run a single-node RustFS instance with Podman and persistent container storage." +description: "Betreiben Sie mit Podman eine RustFS-Instanz auf einem Knoten mit persistentem Containerspeicher." --- -Podman can run the official RustFS Open Container Initiative (OCI) image without a daemon. You need a working Podman installation and permission to create containers. +Podman kann das offizielle Image der Open Container Initiative (OCI) von RustFS ohne Daemon ausführen. Sie benötigen eine funktionsfähige Podman-Installation und die Berechtigung, Container zu erstellen. -## 1. Pull the image +## 1. Image abrufen ```bash podman pull docker.io/rustfs/rustfs:latest ``` -## 2. Create persistent storage +## 2. Persistenten Speicher anlegen -Create a named volume so object data remains available when you replace the container: +Legen Sie ein benanntes Volume an, damit die Objektdaten verfügbar bleiben, wenn Sie den Container ersetzen: ```bash podman volume create rustfs-data ``` -:::note[Bind-mounting a host directory] +:::note[Host-Verzeichnis per Bind-Mount einbinden] -The named volume above needs no extra setup. If you bind-mount a host directory instead, keep in mind that the container runs as non-root user `rustfs` with id `10001`. Make the host directory owned by `10001`, otherwise you will encounter permission denied errors: +Das benannte Volume oben braucht keine weitere Vorbereitung. Wenn Sie stattdessen ein Host-Verzeichnis per Bind-Mount einhängen, läuft der Container als Benutzer `rustfs` ohne Root-Rechte mit der ID `10001`. Der Eigentümer des Host-Verzeichnisses muss `10001` sein, sonst treten Fehler `permission denied` auf: ```bash chown -R 10001:10001 /path/to/host_directory @@ -29,9 +29,9 @@ chown -R 10001:10001 /path/to/host_directory ::: -## 3. Start RustFS +## 3. RustFS starten -Replace the credential placeholders before running the container: +Ersetzen Sie die Platzhalter für die Zugangsdaten, bevor Sie den Container starten: ```bash podman run -d \ @@ -50,25 +50,25 @@ podman run -d \ /data ``` -:::warning[Set credentials when creating the container] +:::warning[Zugangsdaten beim Erstellen des Containers festlegen] -Set unique `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` environment variables before exposing RustFS to a network. Do not use the well-known `rustfsadmin` value for either credential. If the container was started without custom credentials, stop and recreate it with both `-e` options shown above; the `rustfs-data` volume remains intact. +Legen Sie eindeutige Umgebungsvariablen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` fest, bevor Sie RustFS in einem Netzwerk erreichbar machen. Verwenden Sie den allgemein bekannten Wert `rustfsadmin` weder als Zugriffsschlüssel noch als geheimen Zugriffsschlüssel. Wenn der Container ohne eigene Zugangsdaten gestartet wurde, beenden Sie ihn und erstellen Sie ihn mit beiden oben gezeigten `-e`-Optionen neu. Das Volume `rustfs-data` bleibt dabei erhalten. ::: -## 4. Verify the deployment +## 4. Bereitstellung prüfen -Check the container and the S3 API health endpoint: +Prüfen Sie den Container und den Integritätsendpunkt der S3-API: ```bash podman ps --filter name=rustfs curl --fail http://localhost:9000/health ``` -The S3 API is available at `http://localhost:9000`, and the Console is available at `http://localhost:9001`. +Die S3-API ist unter `http://localhost:9000` erreichbar, die Console (Weboberfläche) unter `http://localhost:9001`. -## Next steps +## Nächste Schritte -- [RustFS Console](/administration/console) -- [Configure an S3 client](../../developer/examples/aws-cli.md) -- [TLS configuration](../../integration/tls-configured.md) +- [RustFS Console](/de/administration/console) +- [S3-Client konfigurieren](../../developer/examples/aws-cli.md) +- [TLS-Konfiguration](../../integration/tls-configured.md) diff --git a/content/de/installation/index.md b/content/de/installation/index.md index 3dafcbd5f..a435f26f2 100644 --- a/content/de/installation/index.md +++ b/content/de/installation/index.md @@ -1,43 +1,43 @@ --- title: "Installation" -description: "Choose the right RustFS deployment path: local trial, single-node or multi-node production, containers, and Kubernetes." +description: "Wählen Sie den passenden Bereitstellungspfad für RustFS: lokaler Test, Produktion auf einem oder mehreren Knoten, Container und Kubernetes." --- -RustFS is a distributed object storage system written in Rust and released under the Apache 2.0 license. It runs on Linux, Windows, macOS, FreeBSD, and containers, across x86, ARM, RISC-V, and other CPU architectures. +RustFS ist ein verteiltes Objektspeichersystem. Es ist in Rust geschrieben und steht unter der Apache-2.0-Lizenz. Es läuft auf Linux, Windows, macOS und FreeBSD sowie in Containern, auf x86, ARM, RISC-V und weiteren CPU-Architekturen. :::warning[Nur für Entwicklung und Debugging] -Die Windows-Version von RustFS ist ausschließlich für Entwicklung und Debugging vorgesehen und wird **nicht für Produktionsumgebungen empfohlen**. Für Produktionsumgebungen empfehlen wir [Linux](/de/installation/linux). +Die Windows-Version von RustFS ist ausschließlich für Entwicklung und Debugging vorgesehen und wird **nicht für Produktionsbereitstellungen empfohlen**. Für Produktionsarbeitslasten empfehlen wir [Linux](/de/installation/linux). ::: -:::warning[Change the default credentials immediately] +:::warning[Standardzugangsdaten sofort ändern] -After installation, set unique values for `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` before exposing RustFS to a network. Do not use the well-known `rustfsadmin` value for either credential. +Legen Sie nach der Installation eindeutige Werte für `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` fest, bevor Sie RustFS in einem Netzwerk erreichbar machen. Verwenden Sie den allgemein bekannten Wert `rustfsadmin` weder als Zugriffsschlüssel noch als geheimen Zugriffsschlüssel. -- For a Linux binary or systemd installation, set both values in `/etc/default/rustfs`, then restart the `rustfs` service. -- For Docker, Podman, or Docker Compose, pass both values as container environment variables when creating the container. Recreate an existing container if it was started without them. +- Bei einer Installation als Linux-Binärdatei oder mit systemd tragen Sie beide Werte in `/etc/default/rustfs` ein und starten Sie anschließend den Dienst `rustfs` neu. +- Bei Docker, Podman oder Docker Compose übergeben Sie beide Werte beim Erstellen des Containers als Umgebungsvariablen. Erstellen Sie einen bestehenden Container neu, wenn er ohne diese Werte gestartet wurde. ::: -## Choose Your Path +## Pfad auswählen -| Your goal | Recommended path | Guide | +| Ihr Ziel | Empfohlener Pfad | Anleitung | | - | - | - | -| Try RustFS on a local machine | One-command install script, or a container | [Linux Quick Start](./linux/quick-start.md) · [Container](./container/index.md) | -| Single-server production | SNSD (one disk) or SNMD (multiple disks) | [Installing RustFS on Linux](./linux/index.md) | -| Multi-server production cluster | MNMD, after completing the production checklists | [Multiple Node Multiple Disk](./linux/multiple-node-multiple-disk.md) · [Checklists](./requirement/checklists/index.md) | -| Kubernetes / cloud-native | Container orchestration deployment | [Cloud Native](./cloud-native/index.md) | -| Windows or macOS host | Native installation | [Windows](./windows/index.md) · [macOS](./macos/index.md) | +| RustFS auf einem lokalen Rechner ausprobieren | Installationsskript mit einem Befehl oder ein Container | [Linux-Schnellstart](./linux/quick-start.md) · [Container](./container/index.md) | +| Produktion auf einem Server | SNSD (ein Datenträger) oder SNMD (mehrere Datenträger) | [RustFS unter Linux installieren](./linux/index.md) | +| Produktionscluster auf mehreren Servern | MNMD, nachdem Sie die Produktions-Checklisten abgeschlossen haben | [Mehrere Knoten mit mehreren Datenträgern](./linux/multiple-node-multiple-disk.md) · [Checklisten](./requirement/checklists/index.md) | +| Kubernetes / Cloud-native | Bereitstellung mit dem Helm-Chart oder dem Operator | [Cloud-native](./cloud-native/index.md) | +| Windows- oder macOS-Host | Installation des nativen Programms | [Windows](./windows/index.md) · [macOS](./macos/index.md) | -## Deployment Mode Comparison +## Vergleich der Bereitstellungsmodi -| Mode | Nodes | Disks | Fault Tolerance | Typical Use | +| Modus | Knoten | Datenträger | Fehlertoleranz | Typische Verwendung | | - | - | - | - | - | -| [SNSD](./linux/single-node-single-disk.md) | 1 | 1 | None — rely on backups | Development, testing, low-density non-critical business | -| [SNMD](./linux/single-node-multiple-disk.md) | 1 | Multiple | Up to M parity disks within the node | Medium, non-critical business on a single server | -| [MNMD](./linux/multiple-node-multiple-disk.md) | 4+ | Multiple per node | Disk- and node-level via erasure coding across servers | Production workloads | +| [SNSD](./linux/single-node-single-disk.md) | 1 | 1 | Keine — nur über Sicherungen | Entwicklung, Tests und kleine, nicht kritische Arbeitslasten | +| [SNMD](./linux/single-node-multiple-disk.md) | 1 | Mehrere | Bis zu M Paritätsdatenträger innerhalb des Knotens | Mittlere, nicht kritische Arbeitslasten auf einem Server | +| [MNMD](./linux/multiple-node-multiple-disk.md) | 4+ | Mehrere je Knoten | Datenträger- und Knotenebene durch Erasure Coding über mehrere Server | Produktionsarbeitslasten | -## Checklist +## Checkliste -Before any production deployment, work through the [Pre-Installation Checklists](./requirement/checklists/index.md) — hardware, network, software, and security — to make sure your environment meets production guidance. +Arbeiten Sie vor jeder Produktionsbereitstellung die [Checklisten vor der Installation](./requirement/checklists/index.md) durch — Hardware, Netzwerk, Software und Sicherheit —, damit Ihre Umgebung die Produktionsanforderungen erfüllt. diff --git a/content/de/installation/linux/index.md b/content/de/installation/linux/index.md index 8f9f4f1be..f225dec32 100644 --- a/content/de/installation/linux/index.md +++ b/content/de/installation/linux/index.md @@ -1,34 +1,34 @@ --- -title: "Installing RustFS on Linux" -description: "Choose a Linux deployment mode — SNSD, SNMD, or MNMD — and install RustFS on one or more servers." +title: "RustFS unter Linux installieren" +description: "Wählen Sie einen Linux-Bereitstellungsmodus — SNSD, SNMD oder MNMD — und installieren Sie RustFS auf einem oder mehreren Servern." --- -This section covers installing RustFS on Linux servers. For a one-command trial installation, use the [Quick Start](./quick-start.md). For a manual installation, pick one of the three deployment modes below — all three share the same [prerequisites and service setup](./prerequisites-and-service.md), and differ only in topology and volume configuration. +Dieser Abschnitt beschreibt die Installation von RustFS auf Linux-Servern. Für eine Testinstallation mit einem Befehl verwenden Sie den [Schnellstart](./quick-start.md). Für eine manuelle Installation wählen Sie einen der drei Bereitstellungsmodi unten. Alle drei verwenden dieselben [Voraussetzungen und die Diensteinrichtung](./prerequisites-and-service.md) und unterscheiden sich nur in der Topologie und der Konfiguration der Volumes. -:::warning[Change the default credentials immediately] +:::warning[Standardzugangsdaten sofort ändern] -After installation, set unique `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` values in `/etc/default/rustfs`. Do not use the well-known `rustfsadmin` value for either credential. Restart the service with `sudo systemctl restart rustfs` after changing the file. +Tragen Sie nach der Installation eindeutige Werte für `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` in `/etc/default/rustfs` ein. Verwenden Sie den allgemein bekannten Wert `rustfsadmin` weder als Zugriffsschlüssel noch als geheimen Zugriffsschlüssel. Starten Sie den Dienst nach der Änderung der Datei mit `sudo systemctl restart rustfs` neu. ::: -## Single Node Single Disk (SNSD) +## Einzelner Knoten mit einem Datenträger (SNSD) -One server, one data disk. The simplest mode, with no redundancy — a disk failure means data loss, so rely on backups. Suitable for development, testing, and low-density non-critical business. +Ein Server, ein Datenträger. Der einfachste Modus, ohne Redundanz: Ein Datenträgerausfall bedeutet Datenverlust. Verlassen Sie sich daher auf Sicherungen. Geeignet für Entwicklung, Tests und kleine, nicht kritische Arbeitslasten. -→ [Single Node Single Disk installation](./single-node-single-disk.md) +→ [Installation mit einem Knoten und einem Datenträger](./single-node-single-disk.md) -## Single Node Multiple Disk (SNMD) +## Einzelner Knoten mit mehreren Datenträgern (SNMD) -One server, multiple data disks. Erasure coding shards data across the disks, so the node tolerates a limited number of disk failures, but a whole-server failure still means data loss. Suitable for medium, non-critical business on a single machine. +Ein Server, mehrere Datenträger. Erasure Coding verteilt die Daten als Shards auf die Datenträger. Der Knoten toleriert dadurch eine begrenzte Zahl von Datenträgerausfällen, der Ausfall des gesamten Servers bedeutet jedoch weiterhin Datenverlust. Geeignet für mittlere, nicht kritische Arbeitslasten auf einem Rechner. -→ [Single Node Multiple Disk installation](./single-node-multiple-disk.md) +→ [Installation mit einem Knoten und mehreren Datenträgern](./single-node-multiple-disk.md) -## Multiple Node Multiple Disk (MNMD) +## Mehrere Knoten mit mehreren Datenträgern (MNMD) -Four or more servers, each with one or more disks. Erasure coding spans servers, providing disk- and node-level fault tolerance plus horizontal scalability. This is the mode for production workloads. +Vier oder mehr Server mit jeweils einem oder mehreren Datenträgern. Erasure Coding erstreckt sich über die Server und bietet Fehlertoleranz auf Datenträger- und Knotenebene sowie horizontale Skalierbarkeit. Das ist der Modus für Produktionsarbeitslasten. -→ [Multiple Node Multiple Disk installation](./multiple-node-multiple-disk.md) +→ [Installation mit mehreren Knoten und mehreren Datenträgern](./multiple-node-multiple-disk.md) -## Before Production +## Vor dem Produktivbetrieb -Work through the [Pre-Installation Checklists](../requirement/checklists/index.md) — hardware, network, software, and security — before deploying to production. If you don't need production standards, you can skip them. +Arbeiten Sie die [Checklisten vor der Installation](../requirement/checklists/index.md) durch — Hardware, Netzwerk, Software und Sicherheit —, bevor Sie in der Produktion bereitstellen. Für Bereitstellungen außerhalb der Produktion können Sie sie überspringen. diff --git a/content/de/installation/linux/multiple-node-multiple-disk.md b/content/de/installation/linux/multiple-node-multiple-disk.md index 797c9cd9e..fd382d008 100644 --- a/content/de/installation/linux/multiple-node-multiple-disk.md +++ b/content/de/installation/linux/multiple-node-multiple-disk.md @@ -1,16 +1,16 @@ --- -title: "RustFS Multiple Node Multiple Disk Installation" -description: "Install RustFS on multiple servers with multiple disks, data will be stored on multiple disks across multiple servers." +title: "RustFS-Installation mit mehreren Knoten und mehreren Datenträgern" +description: "Installieren Sie einen verteilten RustFS-Cluster auf mehreren Servern mit jeweils mehreren Datenträgern." --- -Multiple Node Multiple Disk (MNMD) mode is the deployment mode for production workloads, providing enterprise-grade performance, security, and scalability. A minimum of **4 servers** is required, each with at least 1 disk, to safely start a distributed object storage cluster. +Der Modus mit mehreren Knoten und mehreren Datenträgern (MNMD) ist die Produktionsbereitstellung für Cluster, die sich über mehrere Server erstrecken. Mindestens **4 Server** mit jeweils mindestens einem Datenträger sind erforderlich, um einen verteilten Objektspeicher-Cluster sicher zu starten. -## Topology and Planning +## Topologie und Planung -In the following architecture, requests are distributed to the servers through load balancing. With the default 12 + 4 erasure coding layout, each object is split into 12 data shards and 4 parity shards stored on different disks across different servers: +In der folgenden Architektur werden Anfragen über Lastverteilung auf die Server verteilt. Beim standardmäßigen Layout 12 + 4 für Erasure Coding wird jedes Objekt in 12 Datenshards und 4 Paritätsshards aufgeteilt, die auf verschiedenen Datenträgern verschiedener Server gespeichert werden: -- Any single server failure or maintenance does not affect data security. -- Corruption of up to 4 disks does not affect data security. +- Der Cluster bleibt verfügbar und verliert keine Daten, wenn ein einzelner Server ausfällt oder zur Wartung heruntergefahren wird. +- Der Cluster toleriert den Verlust von bis zu 4 Datenträgern ohne Datenverlust. ```mermaid flowchart TD @@ -29,19 +29,19 @@ flowchart TD class N1D1,N1D2,N1D3,N1D4,N2D1,N2D2,N2D3,N2D4,N3D1,N3D2,N3D3,N3D4,N4D1,N4D2,N4D3,N4D4 disk ``` -Before installation, review the [Pre-Installation Checklists](../requirement/checklists/index.md) and ensure all items meet production guidance. +Prüfen Sie vor der Installation die [Checklisten vor der Installation](../requirement/checklists/index.md) und stellen Sie sicher, dass jeder Punkt die Produktionsanforderungen erfüllt. -## Hostnames +## Hostnamen -Creating a RustFS cluster requires **identical, sequential** hostnames. There are two ways to achieve sequential hostnames: +Ein RustFS-Cluster erfordert Hostnamen nach einem einheitlichen, fortlaufend nummerierten Muster (zum Beispiel `node1` bis `node4`). Fortlaufende Hostnamen richten Sie auf zwei Wegen ein: -**1. DNS Configuration:** +**1. DNS-Konfiguration:** -Configure your DNS resolution server to ensure name continuity. +Legen Sie DNS-Einträge an, sodass jeder fortlaufende Hostname auf den richtigen Knoten auflöst. -**2. HOSTS Configuration:** +**2. Konfiguration von `/etc/hosts`:** -Modify the local alias settings in `/etc/hosts` as follows: +Tragen Sie auf jedem Knoten die folgenden Einträge in `/etc/hosts` ein: ```bash title="/etc/hosts" vim /etc/hosts @@ -53,13 +53,13 @@ vim /etc/hosts 192.168.1.4 node4 ``` -## Prerequisites and Service Setup +## Voraussetzungen und Diensteinrichtung -On **every node**, complete the [common prerequisites and service setup](./prerequisites-and-service.md) — operating system, firewall, time synchronization, disk formatting, service user, binary download, and systemd unit — then continue below. Remember that all nodes must use the same listening port and must have synchronized clocks. +Schließen Sie auf **jedem Knoten** die [gemeinsamen Voraussetzungen und die Diensteinrichtung](./prerequisites-and-service.md) ab — Betriebssystem, Firewall, Zeitsynchronisation, Formatierung der Datenträger, Dienstbenutzer, Herunterladen der Binärdatei und systemd-Unit — und fahren Sie anschließend unten fort. Alle Knoten müssen auf demselben Port lauschen und synchronisierte Uhren haben. -## Configure Environment Variables +## Umgebungsvariablen konfigurieren -1. Create the same configuration file on every node. `RUSTFS_VOLUMES` uses brace expansion to enumerate all nodes and all disk mount points (this example: 4 nodes × 4 disks): +1. Legen Sie auf jedem Knoten dieselbe Konfigurationsdatei an. `RUSTFS_VOLUMES` zählt mit einer Brace-Expansion (geschweifte Klammern) alle Knoten und alle Einhängepunkte auf (in diesem Beispiel 4 Knoten × 4 Datenträger): ```ini title="/etc/default/rustfs" # Use a unique access key and a strong, random secret (e.g. openssl rand -base64 24) @@ -75,49 +75,49 @@ RUSTFS_OBS_LOG_DIRECTORY="/var/log/rustfs/" :::note -The access key, secret key, and `RUSTFS_VOLUMES` value must be identical on all nodes. The hostnames (`node1` – `node4`) must match the DNS or `/etc/hosts` configuration above. +Zugriffsschlüssel, geheimer Zugriffsschlüssel und der Wert von `RUSTFS_VOLUMES` müssen auf allen Knoten identisch sein. Die Hostnamen (`node1` – `node4`) müssen zur DNS- oder `/etc/hosts`-Konfiguration oben passen. ::: -2. Create the storage and log directories on every node: +2. Legen Sie auf jedem Knoten die Verzeichnisse für Speicher und Logs an: ```bash sudo mkdir -p /data/rustfs{0..3} /var/log/rustfs /opt/tls sudo chmod -R 750 /data/rustfs* /var/log/rustfs ``` -## Start Service and Verification +## Dienst starten und prüfen -1. Start the service on every node and enable auto-start on boot: +1. Starten Sie den Dienst auf jedem Knoten und aktivieren Sie den automatischen Start beim Systemstart: ```bash sudo systemctl enable --now rustfs ``` -2. Verify the service status: +2. Prüfen Sie den Status des Dienstes: ```bash systemctl status rustfs ``` -3. Check the service port: +3. Prüfen Sie den Port des Dienstes: ```bash netstat -ntpl ``` -4. View log files: +4. Sehen Sie sich die Logdateien an: ```bash tail -f /var/log/rustfs/rustfs*.log ``` -5. Access the console: enter any node's IP address (or the load balancer address) and the console port (default 9001) in a browser. You should see: +5. Öffnen Sie die Console (Weboberfläche): Geben Sie im Browser die IP-Adresse eines beliebigen Knotens (oder die Adresse des Load Balancers) und den Console-Port (Standard 9001) ein. Sie sollten Folgendes sehen: ![Console](./images/console.jpg) -## Next Steps +## Nächste Schritte -- Put a load balancer in front of the cluster — see the [Nginx integration guide](/developer/integration/reverse-proxy/nginx). -- Enable TLS for production traffic — see [TLS configuration](../../integration/tls-configured.md). -- Review [Pool Expansion](../../operations/scaling/storage-pool-expansion.md) before scaling. +- Setzen Sie einen Load Balancer vor den Cluster — siehe die [Nginx-Integrationsanleitung](/de/developer/integration/reverse-proxy/nginx). +- Aktivieren Sie TLS für den Produktivverkehr — siehe [TLS-Konfiguration](../../integration/tls-configured.md). +- Lesen Sie die [Erweiterung des Speicherpools](../../operations/scaling/storage-pool-expansion.md), bevor Sie skalieren. diff --git a/content/de/installation/linux/prerequisites-and-service.md b/content/de/installation/linux/prerequisites-and-service.md index 6a6356776..4dea21d81 100644 --- a/content/de/installation/linux/prerequisites-and-service.md +++ b/content/de/installation/linux/prerequisites-and-service.md @@ -227,6 +227,8 @@ XFS passt aus drei Gründen zur Arbeitslast von RustFS: Zur besseren Datenträgererkennung empfehlen wir, XFS-Dateisysteme mit **Label**-Kennzeichnungen zu formatieren. +Damit Sie Datenträger leichter erkennen und einhängen können, empfehlen wir, beim Formatieren jedes Datenträgers eine Dateisystemkennung (`-L`) zu vergeben. + Prüfen Sie zuerst das Datenträgerlayout: ```bash diff --git a/content/de/installation/linux/quick-start.md b/content/de/installation/linux/quick-start.md index b3afc15eb..d9e52ca22 100644 --- a/content/de/installation/linux/quick-start.md +++ b/content/de/installation/linux/quick-start.md @@ -1,26 +1,26 @@ --- -title: "Quick Start" -description: "Install RustFS with the one-click script, log in to the Console, and store your first object — in about ten minutes." +title: "Schnellstart" +description: "Installieren Sie RustFS mit dem Installationsskript, melden Sie sich an der Console an und speichern Sie Ihr erstes Objekt — in etwa zehn Minuten." --- -This guide takes you from an empty Linux server to a working RustFS instance: install, log in to the Console, create a bucket, and upload your first object. Production planning (multi-node layout, hardware sizing) is deliberately left for [the next step](#next-steps). +Diese Anleitung führt Sie von einem leeren Linux-Server zu einer laufenden RustFS-Instanz. Sie installieren RustFS, melden sich an der Console (Weboberfläche) an, legen einen Bucket an und laden Ihr erstes Objekt hoch. Die Produktionsplanung (Aufbau mit mehreren Knoten, Dimensionierung der Hardware) bleibt bewusst dem [nächsten Schritt](#nächste-schritte) vorbehalten. -**Prerequisites** +**Voraussetzungen** -- A Linux server (x86_64 or aarch64) with `systemd`, and root or sudo access -- `unzip` installed, and outbound network access to download the package -- Ports `9000` (S3 API) and `9001` (Console) reachable from your machine -- [`rc`](/operations/rc) installed on your workstation for the command-line verification workflow +- Ein Linux-Server (x86_64 oder aarch64) mit `systemd` sowie Root- oder sudo-Zugriff +- `unzip` ist installiert, und ausgehender Netzwerkzugriff zum Herunterladen des Pakets ist vorhanden +- Die Ports `9000` (S3-API) und `9001` (Console) sind von Ihrem Rechner aus erreichbar +- [`rc`](/de/operations/rc) ist auf Ihrer Arbeitsstation für den Prüflauf auf der Kommandozeile installiert -## 1. Install and start RustFS +## 1. RustFS installieren und starten -Run the official installation script: +Führen Sie das offizielle Installationsskript aus: ```bash curl -O https://rustfs.com/install_rustfs.sh && bash install_rustfs.sh ``` -The script installs the binary to `/usr/local/bin/rustfs`, registers a `rustfs` systemd service, and starts it. By default it stores data in `/data/rustfs0` and listens on port `9000` (S3 API) and `9001` (Console); the data path and ports can be adjusted during installation. On success it prints a summary like: +Das Skript installiert die Binärdatei nach `/usr/local/bin/rustfs`, registriert einen systemd-Dienst `rustfs` und startet ihn. Standardmäßig speichert es die Daten in `/data/rustfs0` und lauscht auf den Ports `9000` (S3-API) und `9001` (Console). Datenpfad und Ports lassen sich während der Installation anpassen. Bei Erfolg gibt es eine Zusammenfassung in dieser Form aus: ```text RustFS has been installed and started successfully! @@ -30,41 +30,41 @@ Service port: 9000, Console port: 9001, Data directory: /data/rustfs0 Config file: /etc/default/rustfs ``` -## 2. Set your credentials +## 2. Zugangsdaten festlegen -The generated config file ships placeholder credentials. Set your own access key and secret key, then restart the service: +Die erzeugte Konfigurationsdatei enthält Platzhalter für die Zugangsdaten. Legen Sie Ihren eigenen Zugriffsschlüssel und Ihren eigenen geheimen Zugriffsschlüssel fest und starten Sie den Dienst anschließend neu: ```ini title="/etc/default/rustfs" {1,2} RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ; e.g. output of: openssl rand -base64 24 ``` -Use an uppercase alphanumeric access key. Do not use unmodified Base64 output for `RUSTFS_ACCESS_KEY`, because Base64 can contain `/`, which conflicts with the AWS Signature Version 4 credential scope. See [Credential Management](/operations/credentials) for details. +Verwenden Sie einen Zugriffsschlüssel aus Großbuchstaben und Ziffern. Verwenden Sie die unveränderte Base64-Ausgabe nicht für `RUSTFS_ACCESS_KEY`. Base64 kann `/` enthalten. Das kollidiert mit dem Credential Scope von AWS Signature Version 4, also dem Geltungsbereich der Signatur. Einzelheiten stehen in der [Zugangsdatenverwaltung](/de/operations/credentials). ```bash sudo systemctl restart rustfs sudo systemctl status rustfs --no-pager # should report: active (running) ``` -:::warning[Do not keep default credentials] +:::warning[Standardzugangsdaten nicht beibehalten] -If `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` are not set, the server falls back to the built-in default `rustfsadmin` / `rustfsadmin` — acceptable for a throwaway local test, never for anything reachable by others. +Wenn `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` nicht gesetzt sind, fällt der Server auf den eingebauten Standard `rustfsadmin` / `rustfsadmin` zurück. Das ist nur für einen lokalen Test akzeptabel, den Sie anschließend verwerfen, und niemals für eine Instanz, die andere erreichen können. ::: -## 3. Log in to the Console +## 3. An der Console anmelden -Open `http://:9001` in your browser and sign in with the access key and secret key from step 2. +Öffnen Sie `http://:9001` im Browser und melden Sie sich mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel aus Schritt 2 an. -![RustFS Console login](./images/console.jpg) +![Anmeldung an der RustFS Console](./images/console.jpg) -## 4. Create a bucket and upload a file +## 4. Bucket anlegen und eine Datei hochladen -1. In the Console home page, select **Create Bucket**, name it (for example `my-bucket`), and confirm. -2. Open the bucket and use the upload action to add any local file. -3. Click the uploaded object to view its details — you have a working object store. +1. Wählen Sie auf der Startseite der Console **Create Bucket** (Bucket erstellen), vergeben Sie einen Namen (zum Beispiel `my-bucket`) und bestätigen Sie. +2. Öffnen Sie den Bucket und verwenden Sie die Aktion zum Hochladen, um eine beliebige lokale Datei hinzuzufügen. +3. Klicken Sie auf das hochgeladene Objekt, um die Details anzuzeigen. Damit verfügen Sie über einen funktionierenden Objektspeicher. -Prefer the command line? Configure [`rc`](/operations/rc), then perform the same operations: +Sie arbeiten lieber auf der Kommandozeile? Konfigurieren Sie [`rc`](/de/operations/rc) und führen Sie dieselben Operationen aus: ```bash rc alias set rustfs http://:9000 @@ -80,13 +80,13 @@ rc object list rustfs/my-bucket -## Next steps +## Nächste Schritte -The quick install runs RustFS in **Single Node Single Disk (SNSD)** mode — zero redundancy, right for evaluation and development. Where to go from here: +Mit der Schnellinstallation betreiben Sie RustFS im Modus **Einzelner Knoten mit einem Datenträger (SNSD)** — ohne Redundanz, geeignet für Evaluierung und Entwicklung. So geht es weiter: -- **Plan a production deployment** — choose a topology, then follow its guide: - - [Single Node Single Disk (SNSD)](./single-node-single-disk.md) — dev and small workloads - - [Single Node Multiple Disk (SNMD)](./single-node-multiple-disk.md) — disk-level fault tolerance on one machine - - [Multiple Node Multiple Disk (MNMD)](./multiple-node-multiple-disk.md) — production-grade availability and scale, with the [pre-installation checklists](../requirement/checklists/index.md) -- **Prefer containers?** — [Install with a container](../container/index.md) -- **Connect your application** — [SDKs and examples](../../developer/sdk/index.md) +- **Produktionsbereitstellung planen** — wählen Sie eine Topologie und folgen Sie der zugehörigen Anleitung: + - [Einzelner Knoten mit einem Datenträger (SNSD)](./single-node-single-disk.md) — Entwicklung und kleine Arbeitslasten + - [Einzelner Knoten mit mehreren Datenträgern (SNMD)](./single-node-multiple-disk.md) — Fehlertoleranz auf Datenträgerebene auf einem Rechner + - [Mehrere Knoten mit mehreren Datenträgern (MNMD)](./multiple-node-multiple-disk.md) — Verfügbarkeit und Skalierung auf Produktionsniveau, mit den [Checklisten vor der Installation](../requirement/checklists/index.md) +- **Sie bevorzugen Container?** — [Mit einem Container installieren](../container/index.md) +- **Anwendung anbinden** — [SDKs und Beispiele](../../developer/sdk/index.md) diff --git a/content/de/installation/linux/single-node-multiple-disk.md b/content/de/installation/linux/single-node-multiple-disk.md index 4f4c26906..cd7c2d762 100644 --- a/content/de/installation/linux/single-node-multiple-disk.md +++ b/content/de/installation/linux/single-node-multiple-disk.md @@ -1,17 +1,17 @@ --- -title: "RustFS Single Node Multiple Disk Installation" -description: "Install RustFS on a single server with multiple disks, data will be stored on multiple disks." +title: "RustFS-Installation mit einem einzelnen Knoten und mehreren Datenträgern" +description: "Installieren Sie RustFS auf einem einzelnen Server und verteilen Sie die Daten auf mehrere Datenträger." --- -In Single Node Multiple Disk (SNMD) mode, one server stores data in sharded form across multiple data disks. Each object is split into K data shards and M parity shards (erasure coding), so the loss of up to M disks does not cause data loss. +Im Modus mit einem einzelnen Knoten und mehreren Datenträgern (SNMD) verteilt ein Server die Daten auf mehrere Datenträger. Jedes Objekt wird in K Datenshards und M Paritätsshards aufgeteilt (Erasure Coding). Der Ausfall von bis zu M Datenträgern führt daher nicht zu Datenverlust. :::warning -SNMD is suitable for medium, non-critical business. Damage to at most M disks does not pose a data risk, but if the entire server fails or more than M disks are damaged, data will be lost. Keep backups of important data. For node-level fault tolerance, use [MNMD](./multiple-node-multiple-disk.md). +SNMD eignet sich für mittlere, nicht kritische Arbeitslasten. Die Bereitstellung kann bis zu M Datenträger verlieren, ohne dass Daten verloren gehen. Fällt jedoch der gesamte Server aus oder sind mehr als M Datenträger beschädigt, gehen die Daten verloren. Sichern Sie wichtige Daten. Für Fehlertoleranz auf Knotenebene verwenden Sie [MNMD](./multiple-node-multiple-disk.md). ::: -## Topology and Planning +## Topologie und Planung ```mermaid flowchart TD @@ -23,18 +23,18 @@ flowchart TD class D1,D2,D3,D4 disk ``` -- 1 server with multiple data disks (this example uses 4 disks mounted at `/data/rustfs0` through `/data/rustfs3`). -- Erasure coding spreads data and parity shards across the disks; fault tolerance is limited to disk failures within the single node. -- Format each disk with XFS and mount it separately (e.g., labels `RUSTFS0` – `RUSTFS3`), as described in the prerequisites page. -- For production deployments, also review the [Pre-Installation Checklists](../requirement/checklists/index.md). +- 1 Server mit mehreren Datenträgern (dieses Beispiel verwendet 4 Datenträger, eingehängt unter `/data/rustfs0` bis `/data/rustfs3`). +- Erasure Coding verteilt Daten- und Paritätsshards auf die Datenträger. Die Fehlertoleranz beschränkt sich auf Datenträgerausfälle innerhalb des einzelnen Knotens. +- Formatieren Sie jeden Datenträger mit XFS und hängen Sie ihn getrennt ein (zum Beispiel mit den Labels `RUSTFS0` – `RUSTFS3`), wie auf der Seite zu den Voraussetzungen beschrieben. +- Prüfen Sie für Produktionsbereitstellungen zusätzlich die [Checklisten vor der Installation](../requirement/checklists/index.md). -## Prerequisites and Service Setup +## Voraussetzungen und Diensteinrichtung -Complete the [common prerequisites and service setup](./prerequisites-and-service.md) — operating system, firewall, time synchronization, disk formatting, service user, binary download, and systemd unit — then continue below. +Schließen Sie die [gemeinsamen Voraussetzungen und die Diensteinrichtung](./prerequisites-and-service.md) ab — Betriebssystem, Firewall, Zeitsynchronisation, Formatierung der Datenträger, Dienstbenutzer, Herunterladen der Binärdatei und systemd-Unit — und fahren Sie anschließend unten fort. -## Configure Environment Variables +## Umgebungsvariablen konfigurieren -1. Create the configuration file. `RUSTFS_VOLUMES` uses brace expansion to enumerate the four disk mount points: +1. Legen Sie die Konfigurationsdatei an. `RUSTFS_VOLUMES` zählt die vier Einhängepunkte der Datenträger mit einer Brace-Expansion (geschweifte Klammern) auf: ```ini title="/etc/default/rustfs" # Use a unique access key and a strong, random secret (e.g. openssl rand -base64 24) @@ -48,44 +48,44 @@ RUSTFS_OBS_LOGGER_LEVEL=error RUSTFS_OBS_LOG_DIRECTORY="/var/log/rustfs/" ``` -2. Create the storage and log directories: +2. Legen Sie die Verzeichnisse für Speicher und Logs an: ```bash sudo mkdir -p /data/rustfs{0..3} /var/log/rustfs /opt/tls sudo chmod -R 750 /data/rustfs* /var/log/rustfs ``` -## Start Service and Verification +## Dienst starten und prüfen -1. Start the service and enable auto-start on boot: +1. Starten Sie den Dienst und aktivieren Sie den Start beim Systemstart: ```bash sudo systemctl enable --now rustfs ``` -2. Verify the service status: +2. Prüfen Sie den Status des Dienstes: ```bash systemctl status rustfs ``` -3. Check the service port: +3. Prüfen Sie den Port des Dienstes: ```bash netstat -ntpl ``` -4. View log files: +4. Sehen Sie sich die Logdateien an: ```bash tail -f /var/log/rustfs/rustfs*.log ``` -5. Access the console: enter the server's IP address and the console port (default 9001) in a browser. You should see: +5. Öffnen Sie die Console (Weboberfläche): Geben Sie im Browser die IP-Adresse des Servers und den Console-Port (Standard 9001) ein. Sie sollten Folgendes sehen: ![Console](./images/console.jpg) -## Next Steps +## Nächste Schritte -- Need node-level fault tolerance and horizontal scalability? See [Multiple Node Multiple Disk Mode (MNMD)](./multiple-node-multiple-disk.md). -- Just experimenting? [Single Node Single Disk Mode (SNSD)](./single-node-single-disk.md) is simpler to set up. +- Benötigen Sie Fehlertoleranz auf Knotenebene und horizontale Skalierbarkeit? Siehe [Modus mit mehreren Knoten und mehreren Datenträgern (MNMD)](./multiple-node-multiple-disk.md). +- Sie probieren RustFS nur aus? [Der Modus mit einem einzelnen Knoten und einem Datenträger (SNSD)](./single-node-single-disk.md) lässt sich einfacher einrichten. diff --git a/content/de/installation/linux/single-node-single-disk.md b/content/de/installation/linux/single-node-single-disk.md index b6c96e62f..45c6f18ba 100644 --- a/content/de/installation/linux/single-node-single-disk.md +++ b/content/de/installation/linux/single-node-single-disk.md @@ -1,17 +1,17 @@ --- -title: RustFS Single Node Single Disk Installation -description: Install RustFS on a single disk of a single server, data will be stored on this one disk. +title: "RustFS-Installation mit einem einzelnen Knoten und einem Datenträger" +description: "Installieren Sie RustFS auf einem einzelnen Server, der alle Daten auf einem Datenträger speichert." --- -In Single Node Single Disk (SNSD) mode, one server stores all data on a single data disk. It is the simplest deployment mode and the same topology that the [Linux Quick Start](./quick-start.md) script sets up. +Im Modus mit einem einzelnen Knoten und einem Datenträger (SNSD) speichert ein Server alle Daten auf einem Datenträger. Das ist der einfachste Bereitstellungsmodus und dieselbe Topologie, die das Skript im [Linux-Schnellstart](./quick-start.md) einrichtet. :::warning -A single disk offers no redundancy: if the disk fails, data is lost. SNSD is suitable for development, testing, and low-density non-critical business. For production use, maintain regular data backups or choose [SNMD](./single-node-multiple-disk.md) / [MNMD](./multiple-node-multiple-disk.md). +Ein einzelner Datenträger bietet keine Redundanz: Fällt er aus, gehen die Daten verloren. SNSD eignet sich für Entwicklung, Tests und kleine, nicht kritische Arbeitslasten. Sichern Sie für den Produktionseinsatz die Daten regelmäßig oder wählen Sie [SNMD](./single-node-multiple-disk.md) / [MNMD](./multiple-node-multiple-disk.md). ::: -## Topology and Planning +## Topologie und Planung ```mermaid flowchart TD @@ -23,17 +23,17 @@ flowchart TD class D1 disk ``` -- 1 server, 1 data disk (e.g., an XFS-formatted disk mounted at `/data/rustfs0`). -- No erasure coding across disks — fault tolerance depends entirely on backups. -- For production deployments, also review the [Pre-Installation Checklists](../requirement/checklists/index.md). +- 1 Server, 1 Datenträger (zum Beispiel ein mit XFS formatierter Datenträger, eingehängt unter `/data/rustfs0`). +- Kein Erasure Coding über mehrere Datenträger — die Fehlertoleranz hängt vollständig von Sicherungen ab. +- Prüfen Sie für Produktionsbereitstellungen zusätzlich die [Checklisten vor der Installation](../requirement/checklists/index.md). -## Prerequisites and Service Setup +## Voraussetzungen und Diensteinrichtung -Complete the [common prerequisites and service setup](./prerequisites-and-service.md) — operating system, firewall, time synchronization, disk formatting, service user, binary download, and systemd unit — then continue below. +Schließen Sie die [gemeinsamen Voraussetzungen und die Diensteinrichtung](./prerequisites-and-service.md) ab — Betriebssystem, Firewall, Zeitsynchronisation, Formatierung der Datenträger, Dienstbenutzer, Herunterladen der Binärdatei und systemd-Unit — und fahren Sie anschließend unten fort. -## Configure Environment Variables +## Umgebungsvariablen konfigurieren -1. Create the configuration file with the single-disk volume path: +1. Legen Sie die Konfigurationsdatei an und tragen Sie den Pfad des einzelnen Datenträgers ein: ```ini title="/etc/default/rustfs" # Use a unique access key and a strong, random secret (e.g. openssl rand -base64 24) @@ -47,44 +47,44 @@ RUSTFS_OBS_LOGGER_LEVEL=error RUSTFS_OBS_LOG_DIRECTORY="/var/log/rustfs/" ``` -2. Create the storage and log directories: +2. Legen Sie die Verzeichnisse für Speicher und Logs an: ```bash sudo mkdir -p /data/rustfs0 /var/log/rustfs /opt/tls sudo chmod -R 750 /data/rustfs* /var/log/rustfs ``` -## Start Service and Verification +## Dienst starten und prüfen -1. Start the service and enable auto-start on boot: +1. Starten Sie den Dienst und aktivieren Sie den Start beim Systemstart: ```bash sudo systemctl enable --now rustfs ``` -2. Verify the service status: +2. Prüfen Sie den Status des Dienstes: ```bash systemctl status rustfs ``` -3. Check the service port: +3. Prüfen Sie den Port des Dienstes: ```bash netstat -ntpl ``` -4. View log files: +4. Sehen Sie sich die Logdateien an: ```bash tail -f /var/log/rustfs/rustfs*.log ``` -5. Access the console: enter the server's IP address and the console port (default 9001) in a browser. You should see: +5. Öffnen Sie die Console (Weboberfläche): Rufen Sie im Browser `http://:9001` auf. Sie sollten Folgendes sehen: ![Console](./images/console.jpg) -## Next Steps +## Nächste Schritte -- Need disk-level redundancy on one server? See [Single Node Multiple Disk Mode (SNMD)](./single-node-multiple-disk.md). -- Need a production cluster? See [Multiple Node Multiple Disk Mode (MNMD)](./multiple-node-multiple-disk.md). +- Benötigen Sie Redundanz auf Datenträgerebene auf einem Server? Siehe [Modus mit einem einzelnen Knoten und mehreren Datenträgern (SNMD)](./single-node-multiple-disk.md). +- Benötigen Sie einen Produktionscluster? Siehe [Modus mit mehreren Knoten und mehreren Datenträgern (MNMD)](./multiple-node-multiple-disk.md). diff --git a/content/de/installation/macos/index.md b/content/de/installation/macos/index.md index 2cb290a79..c4c9457eb 100644 --- a/content/de/installation/macos/index.md +++ b/content/de/installation/macos/index.md @@ -1,124 +1,124 @@ --- -title: "Install RustFS on macOS" -description: "Install a local RustFS instance on macOS with RustFS Launcher or the standalone server binary." +title: "RustFS unter macOS installieren" +description: "Installieren Sie eine lokale RustFS-Instanz unter macOS mit RustFS Launcher oder der eigenständigen Server-Binary." --- -This guide provides two ways to run **RustFS** on macOS: use the graphical **RustFS Launcher**, or run the standalone server binary from Terminal. Both methods create a local, single-node instance suitable for evaluation, development, and testing. +Diese Anleitung zeigt zwei Wege, **RustFS** auf macOS zu betreiben: über die grafische Anwendung **RustFS Launcher** oder über die eigenständige Server-Binary im Terminal. Beide Wege erzeugen eine lokale Einzelknoten-Instanz für Evaluierung, Entwicklung und Tests. -:::note[Deployment scope] +:::note[Geltungsbereich der Bereitstellung] -These procedures run RustFS as a desktop process, not as a macOS background service. For a production or distributed deployment, use the [Linux installation guides](/installation/linux). +Diese Verfahren führen RustFS als Desktop-Prozess aus, nicht als Hintergrunddienst von macOS. Für eine produktive oder verteilte Bereitstellung verwenden Sie die [Linux-Installationsanleitungen](/de/installation/linux). ::: -## 1. Check your Mac architecture +## 1. Mac-Architektur prüfen -RustFS distinguishes between Apple Silicon (`arm64`) and Intel (`x86_64`) Macs. Open Terminal and run: +RustFS stellt unterschiedliche Binaries für Apple Silicon (`arm64`) und Intel (`x86_64`) bereit. Öffnen Sie das Terminal und führen Sie Folgendes aus: ```bash uname -m ``` -Use the result to choose the correct package: +Wählen Sie anhand des Ergebnisses das passende Paket: -| Result | Mac type | Current standalone binary availability | +| Ergebnis | Mac-Typ | Verfügbarkeit der aktuellen eigenständigen Binary | | --- | --- | --- | -| `arm64` | Apple Silicon | Download the macOS AArch64 package from current RustFS releases. | -| `x86_64` | Intel | RustFS releases after `v1.0.0-beta.9` do not provide a prebuilt Intel macOS package. Build the current version from source. | +| `arm64` | Apple Silicon | Laden Sie das macOS-AArch64-Paket aus den aktuellen RustFS-Releases herunter. | +| `x86_64` | Intel | RustFS-Releases nach `v1.0.0-beta.9` enthalten kein vorgefertigtes Intel-macOS-Paket. Bauen Sie die aktuelle Version aus dem Quellcode. | -:::warning[Intel Mac release boundary] +:::warning[Grenze der Intel-Mac-Releases] -Do not run the Apple Silicon binary on an Intel Mac. If you need a RustFS version newer than `v1.0.0-beta.9` on Intel macOS, follow the source-build procedure in this guide. An older beta.9 binary does not contain fixes and features from later releases. +Führen Sie die Apple-Silicon-Binary nicht auf einem Intel-Mac aus. Wenn Sie auf Intel-macOS eine RustFS-Version neuer als `v1.0.0-beta.9` benötigen, folgen Sie dem Quellcode-Build in dieser Anleitung. Eine ältere beta.9-Binary enthält keine Korrekturen und Funktionen späterer Releases. ::: -Before continuing, also make sure that: +Stellen Sie vor dem Fortfahren außerdem Folgendes sicher: -- You have permission to install or run applications and write to the selected data directory. -- TCP ports `9000` and `9001` are available, or you have selected two other unused ports. -- You have created a dedicated data directory, such as `$HOME/rustfs/data`. +- Sie dürfen Anwendungen installieren oder ausführen und in das gewählte Datenverzeichnis schreiben. +- Die TCP-Ports `9000` und `9001` sind frei, oder Sie haben zwei andere ungenutzte Ports gewählt. +- Sie haben ein eigenes Datenverzeichnis angelegt, zum Beispiel `$HOME/rustfs/data`. ```bash mkdir -p "$HOME/rustfs/data" ``` -:::warning[Protect the data directory] +:::warning[Datenverzeichnis schützen] -Use an empty directory on a disk with enough free space. Do not store unrelated files in this directory, and do not edit RustFS data files while the server is running. +Verwenden Sie ein leeres Verzeichnis auf einem Datenträger mit ausreichend freiem Speicher. Legen Sie dort keine fremden Dateien ab und bearbeiten Sie RustFS-Datendateien nicht, während der Server läuft. ::: -## 2. Choose an installation method +## 2. Installationsmethode wählen -| Method | Use it when | Architecture note | +| Methode | Geeignet, wenn | Hinweis zur Architektur | | --- | --- | --- | -| RustFS Launcher | You want a graphical setup and built-in log viewer. | Download a Launcher package that matches Apple Silicon or Intel. | -| Standalone binary | You want explicit Terminal commands or scripting. | Current releases provide Apple Silicon binaries; Intel users build releases after beta.9 from source. | +| RustFS Launcher | Sie eine grafische Einrichtung und eine integrierte Protokollanzeige möchten. | Laden Sie ein Launcher-Paket herunter, das zu Apple Silicon oder Intel passt. | +| Eigenständige Binary | Sie explizite Terminal-Befehle oder Skripte möchten. | Aktuelle Releases stellen Apple-Silicon-Binaries bereit. Intel-Nutzer bauen Releases nach beta.9 aus dem Quellcode. | -## Install with RustFS Launcher +## Mit RustFS Launcher installieren -### 3. Download and install Launcher +### 3. Launcher herunterladen und installieren -1. Open the [RustFS Launcher Releases page](https://github.com/rustfs/launcher/releases). -2. Select the latest release and expand **Assets**. -3. Download the macOS installer that matches your architecture: AArch64 for Apple Silicon or x86-64 for Intel. Do not download **Source code** unless you intend to build Launcher yourself. -4. Open the downloaded disk image and move **RustFS Launcher** to **Applications**. -5. Open **RustFS Launcher** from **Applications**. +1. Öffnen Sie die [Release-Seite von RustFS Launcher](https://github.com/rustfs/launcher/releases). +2. Wählen Sie das neueste Release und klappen Sie **Assets** auf. +3. Laden Sie das macOS-Installationsprogramm herunter, das zu Ihrer Architektur passt: AArch64 für Apple Silicon oder x86-64 für Intel. Laden Sie **Source code** nur herunter, wenn Sie Launcher selbst bauen möchten. +4. Öffnen Sie das heruntergeladene Festplattenabbild und verschieben Sie **RustFS Launcher** nach **Applications** (Programme). +5. Öffnen Sie **RustFS Launcher** aus **Applications**. -If macOS blocks the first launch, confirm that the package came from the official `rustfs/launcher` Releases page. Then open **System Settings > Privacy & Security** and allow that specific application. Do not disable Gatekeeper globally. +Wenn macOS den ersten Start blockiert, prüfen Sie, dass das Paket von der offiziellen Release-Seite `rustfs/launcher` stammt. Öffnen Sie anschließend **System Settings > Privacy & Security** (Systemeinstellungen > Datenschutz und Sicherheit) und erlauben Sie genau diese Anwendung. Deaktivieren Sie Gatekeeper nicht global. -### 4. Configure Launcher +### 4. Launcher konfigurieren -Configure the fields in the Launcher window: +Konfigurieren Sie die Felder im Launcher-Fenster: -| Section | Field | Recommended value | Description | +| Bereich | Feld | Empfohlener Wert | Beschreibung | | --- | --- | --- | --- | -| Dataset Mount | Data Path | `$HOME/rustfs/data` | Existing directory where RustFS stores object data. | -| Ports & Access | API Port | `9000` | S3-compatible API port. | -| Ports & Access | Host | `127.0.0.1` | Restricts access to this Mac. | -| Ports & Access | Console Endpoint | Enabled | Enables the web Console; Launcher disables it by default. | -| Ports & Access | Console Port | `9001` | Console port, which must differ from the API port. | -| Credentials | Access Key | `` | Administrator access key for this instance. | -| Credentials | Secret Key | `` | Administrator secret key for this instance. | +| Dataset Mount | Data Path | `$HOME/rustfs/data` | Vorhandenes Verzeichnis, in dem RustFS Objektdaten speichert. | +| Ports & Access | API Port | `9000` | Port der S3-kompatiblen API. | +| Ports & Access | Host | `127.0.0.1` | Beschränkt den Zugriff auf diesen Mac. | +| Ports & Access | Console Endpoint | Enabled | Aktiviert die Console (Weboberfläche). Launcher deaktiviert sie standardmäßig. | +| Ports & Access | Console Port | `9001` | Console-Port. Er muss sich vom API-Port unterscheiden. | +| Credentials | Access Key | `` | Administrator-Zugriffsschlüssel für diese Instanz. | +| Credentials | Secret Key | `` | Geheimer Administrator-Zugriffsschlüssel für diese Instanz. | -Use **Browse** to select the data directory or drag it into Launcher. Launcher requires the directory to exist before startup. The macOS file picker displays the expanded path instead of the literal `$HOME` variable. +Wählen Sie das Datenverzeichnis mit **Browse** oder ziehen Sie es in Launcher. Launcher setzt voraus, dass das Verzeichnis vor dem Start existiert. Die macOS-Dateiauswahl zeigt den aufgelösten Pfad an, nicht die literale Variable `$HOME`. -Replace the credential placeholders with your own values. Launcher initially displays default local-test credentials; do not retain them on a Mac accessible by other users. +Ersetzen Sie die Platzhalter für die Zugangsdaten durch eigene Werte. Launcher zeigt anfangs die standardmäßigen lokalen Test-Zugangsdaten an. Behalten Sie sie nicht auf einem Mac bei, auf den andere Benutzer zugreifen können. -:::warning[Network exposure] +:::warning[Netzwerkexposition] -Keep **Host** set to `127.0.0.1` unless another computer must connect to RustFS. A non-loopback address exposes the API and Console on the corresponding network interfaces. Configure the macOS firewall and strong credentials before allowing remote access. +Lassen Sie **Host** auf `127.0.0.1`, sofern nicht ein anderer Computer eine Verbindung zu RustFS herstellen muss. Jede Adresse außer `127.0.0.1` legt die API und die Console auf den zugehörigen Netzwerkschnittstellen offen. Konfigurieren Sie die macOS-Firewall und starke Zugangsdaten, bevor Sie Fernzugriff zulassen. ::: -### 5. Start and verify RustFS +### 5. RustFS starten und prüfen -1. Select **Launch RustFS**. -2. Wait for Launcher to report that the configured endpoint is online. -3. Open `http://localhost:9001` and sign in with the access key and secret key that you configured. -4. Use `http://localhost:9000` as the endpoint for S3-compatible clients. +1. Wählen Sie **Launch RustFS**. +2. Warten Sie, bis Launcher meldet, dass der konfigurierte Endpunkt online ist. +3. Öffnen Sie `http://localhost:9001` und melden Sie sich mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel an, die Sie konfiguriert haben. +4. Verwenden Sie `http://localhost:9000` als Endpunkt für S3-kompatible Clients. -![RustFS Launcher showing the service online with API port 9000, Console port 9001, and successful startup logs](../windows/images/windows-rustfs-launcher.jpg) +![RustFS Launcher mit online gemeldetem Dienst, API-Port 9000, Console-Port 9001 und erfolgreichen Startprotokollen](../windows/images/windows-rustfs-launcher.jpg) -If you changed the host or ports, use those values instead. The Console URL is available only when **Console Endpoint** is enabled. +Wenn Sie Host oder Ports geändert haben, verwenden Sie diese Werte. Die Console-URL ist nur verfügbar, wenn **Console Endpoint** aktiviert ist. -Launcher locks its configuration while it manages a running process. It also creates a `logs` directory next to the data directory. For example, selecting `$HOME/rustfs/data` places server log files under `$HOME/rustfs/logs`. +Launcher sperrt seine Konfiguration, solange er einen laufenden Prozess verwaltet. Er legt außerdem ein Verzeichnis `logs` neben dem Datenverzeichnis an. Wenn Sie beispielsweise `$HOME/rustfs/data` wählen, liegen die Server-Protokolldateien unter `$HOME/rustfs/logs`. -### 6. Stop or exit Launcher +### 6. Launcher anhalten oder beenden -Select **Stop RustFS** before changing configuration, disconnecting an external data disk, or shutting down macOS. +Wählen Sie **Stop RustFS**, bevor Sie die Konfiguration ändern, einen externen Datenträger trennen oder macOS herunterfahren. -Closing the Launcher window hides it in the menu bar; it does not stop RustFS. To stop the managed process and exit Launcher, open the Launcher menu bar icon and select **Quit**. Select **Show**, or select the icon, to restore the window. +Wenn Sie das Launcher-Fenster schließen, wird es in der Menüleiste ausgeblendet. RustFS wird dadurch nicht angehalten. Um den verwalteten Prozess anzuhalten und Launcher zu beenden, öffnen Sie das Launcher-Symbol in der Menüleiste und wählen Sie **Quit**. Wählen Sie **Show** oder das Symbol, um das Fenster wiederherzustellen. -## Install the standalone binary +## Eigenständige Binary installieren -### 7. Download the Apple Silicon binary +### 7. Apple-Silicon-Binary herunterladen -Use this procedure when `uname -m` returns `arm64`: +Verwenden Sie dieses Verfahren, wenn `uname -m` den Wert `arm64` zurückgibt: -1. Open the [RustFS Releases page](https://github.com/rustfs/rustfs/releases). -2. Select the required release and download the macOS AArch64 ZIP archive from **Assets**. The asset name begins with `rustfs-macos-aarch64`. -3. Create a program directory and extract the archive. Replace `` with the version in the downloaded filename: +1. Öffnen Sie die [RustFS-Release-Seite](https://github.com/rustfs/rustfs/releases). +2. Wählen Sie das benötigte Release und laden Sie das macOS-AArch64-ZIP-Archiv aus **Assets** herunter. Der Asset-Name beginnt mit `rustfs-macos-aarch64`. +3. Legen Sie ein Programmverzeichnis an und entpacken Sie das Archiv. Ersetzen Sie `` durch die Version im heruntergeladenen Dateinamen: ```bash mkdir -p "$HOME/rustfs/bin" @@ -127,20 +127,20 @@ chmod +x "$HOME/rustfs/bin/rustfs" "$HOME/rustfs/bin/rustfs" --help ``` -If the archive contains a platform-specific binary name instead of `rustfs`, use that filename in the remaining commands or rename it to `$HOME/rustfs/bin/rustfs`. +Wenn das Archiv einen plattformspezifischen Binary-Namen anstelle von `rustfs` enthält, verwenden Sie diesen Dateinamen in den weiteren Befehlen oder benennen Sie die Datei in `$HOME/rustfs/bin/rustfs` um. -### 8. Build the Intel binary from source +### 8. Intel-Binary aus dem Quellcode bauen -Use this procedure when `uname -m` returns `x86_64` and you need a release newer than `v1.0.0-beta.9`. +Verwenden Sie dieses Verfahren, wenn `uname -m` den Wert `x86_64` zurückgibt und Sie ein Release neuer als `v1.0.0-beta.9` benötigen. -1. Install the Xcode command-line tools: +1. Installieren Sie die Xcode-Befehlszeilenwerkzeuge: ```bash xcode-select --install ``` -2. Install the current stable Rust toolchain from [rustup.rs](https://rustup.rs/), then open a new Terminal session. -3. Clone RustFS and check out the release that you need: +2. Installieren Sie die aktuelle stabile Rust-Toolchain von [rustup.rs](https://rustup.rs/) und öffnen Sie anschließend eine neue Terminal-Sitzung. +3. Klonen Sie RustFS und checken Sie das benötigte Release aus: ```bash git clone https://github.com/rustfs/rustfs.git @@ -148,23 +148,23 @@ cd rustfs git checkout ``` -4. Build the Intel macOS target with the repository build script: +4. Bauen Sie das Intel-macOS-Ziel mit dem Build-Skript des Repositorys: ```bash ./build-rustfs.sh --platform x86_64-apple-darwin ``` -The build script includes Console assets by default and verifies the resulting binary. Use the binary reported at the end of the build output in the next step. +Das Build-Skript bindet die Console-Assets standardmäßig ein und prüft die erzeugte Binary. Verwenden Sie im nächsten Schritt die Binary, die am Ende der Build-Ausgabe gemeldet wird. -:::note[Source-build dependencies] +:::note[Abhängigkeiten des Quellcode-Builds] -Building from source requires the tools used by the selected RustFS release in addition to Rust and the Xcode command-line tools. If the build reports a missing dependency, follow the requirements in that release's repository README rather than substituting a binary built for Apple Silicon. +Für den Build aus dem Quellcode benötigen Sie zusätzlich zu Rust und den Xcode-Befehlszeilenwerkzeugen die Werkzeuge des gewählten RustFS-Releases. Wenn der Build eine fehlende Abhängigkeit meldet, folgen Sie den Anforderungen in der README dieses Releases im Repository. Setzen Sie keine für Apple Silicon gebaute Binary ein. ::: -### 9. Start the standalone server +### 9. Eigenständigen Server starten -Set credentials for the current Terminal session and assign the path to your downloaded or compiled binary: +Setzen Sie die Zugangsdaten für die aktuelle Terminal-Sitzung und weisen Sie den Pfad zu Ihrer heruntergeladenen oder gebauten Binary zu: ```bash export RUSTFS_ACCESS_KEY="" @@ -178,72 +178,72 @@ export RUSTFS_BIN="$HOME/rustfs/bin/rustfs" "$HOME/rustfs/data" ``` -For an Intel source build, replace `RUSTFS_BIN` with the binary path printed by `build-rustfs.sh`. Keep the Terminal window open while RustFS is running. Press `Control+C` to stop the server. +Ersetzen Sie bei einem Intel-Quellcode-Build `RUSTFS_BIN` durch den Binary-Pfad, den `build-rustfs.sh` ausgibt. Lassen Sie das Terminal-Fenster geöffnet, solange RustFS läuft. Drücken Sie `Control+C`, um den Server anzuhalten. -:::tip[Credential handling] +:::tip[Umgang mit Zugangsdaten] -Session environment variables avoid placing credentials directly in the command line. For repeated or automated use, prefer the `RUSTFS_ACCESS_KEY_FILE` and `RUSTFS_SECRET_KEY_FILE` environment variables and protect those files with macOS permissions. +Sitzungs-Umgebungsvariablen vermeiden es, Zugangsdaten direkt in die Befehlszeile zu schreiben. Bevorzugen Sie für wiederholte oder automatisierte Nutzung die Umgebungsvariablen `RUSTFS_ACCESS_KEY_FILE` und `RUSTFS_SECRET_KEY_FILE` und schützen Sie diese Dateien mit macOS-Berechtigungen. ::: -### 10. Verify the standalone server +### 10. Eigenständigen Server prüfen -Open `http://localhost:9001` and sign in with the configured credentials. Use `http://localhost:9000` as the endpoint for S3-compatible clients. RustFS defaults to path-style addressing, so configure clients accordingly. +Öffnen Sie `http://localhost:9001` und melden Sie sich mit den konfigurierten Zugangsdaten an. Verwenden Sie `http://localhost:9000` als Endpunkt für S3-kompatible Clients. RustFS verwendet standardmäßig pfadbasierte Adressierung (Path-Style). Konfigurieren Sie die Clients entsprechend. -To perform an end-to-end check, create a bucket named `my-bucket`, upload `hello.txt`, and confirm that the object appears in the bucket. +Prüfen Sie den Ablauf durchgehend: Legen Sie einen Bucket namens `my-bucket` an, laden Sie `hello.txt` hoch und prüfen Sie, dass das Objekt im Bucket erscheint. -## Confirm a successful installation +## Erfolgreiche Installation bestätigen -Whether you used Launcher, an Apple Silicon binary, or an Intel source build, a successful Console sign-in opens the **Buckets** page. +Nach der Anmeldung an der Console öffnet sich die Seite **Buckets**, unabhängig davon, ob Sie Launcher, eine Apple-Silicon-Binary oder einen Intel-Quellcode-Build verwendet haben. -![RustFS Console Buckets page after a successful sign-in](../windows/images/rustfs-console-login.png) +![Seite Buckets der RustFS Console nach erfolgreicher Anmeldung](../windows/images/rustfs-console-login.png) -## Troubleshooting +## Fehlerbehebung -### macOS blocks the application or binary +### macOS blockiert die Anwendung oder die Binary -Verify that the file came from the official RustFS GitHub organization. For Launcher, allow the specific application under **System Settings > Privacy & Security**. For a standalone binary that macOS has quarantined, inspect the warning and verify the download source before changing its security attributes. +Prüfen Sie, dass die Datei aus der offiziellen GitHub-Organisation von RustFS stammt. Erlauben Sie bei Launcher die konkrete Anwendung unter **System Settings > Privacy & Security**. Wenn macOS eine eigenständige Binary unter Quarantäne gestellt hat, lesen Sie die Warnung und prüfen Sie die Bezugsquelle, bevor Sie die Sicherheitsattribute ändern. -### The binary architecture does not match +### Die Architektur der Binary stimmt nicht überein -Run `uname -m` and inspect the binary: +Führen Sie `uname -m` aus und prüfen Sie die Binary: ```bash uname -m file "$RUSTFS_BIN" ``` -Use an AArch64 binary on Apple Silicon. On an Intel Mac, build releases after `v1.0.0-beta.9` from source for `x86_64-apple-darwin`. +Verwenden Sie auf Apple Silicon eine AArch64-Binary. Bauen Sie auf einem Intel-Mac Releases nach `v1.0.0-beta.9` aus dem Quellcode für `x86_64-apple-darwin`. -### The data path is rejected +### Der Datenpfad wird abgelehnt -Confirm that the directory exists and that your macOS account has read and write access. Launcher does not create the selected data directory for you. +Prüfen Sie, dass das Verzeichnis existiert und Ihr macOS-Konto Lese- und Schreibzugriff hat. Launcher legt das gewählte Datenverzeichnis nicht für Sie an. -### The API or Console port is unavailable +### Der API- oder Console-Port ist nicht verfügbar -The ports must be numbers from `1` to `65535`, must differ from each other, and must not already be in use. Inspect the default ports: +Die Ports müssen Zahlen von `1` bis `65535` sein, sich voneinander unterscheiden und dürfen nicht bereits belegt sein. Prüfen Sie die Standardports: ```bash lsof -nP -iTCP:9000 -iTCP:9001 -sTCP:LISTEN ``` -Stop the conflicting application or select unused ports, then start RustFS again. +Beenden Sie die kollidierende Anwendung oder wählen Sie freie Ports und starten Sie RustFS erneut. -### The Console does not open +### Die Console öffnet sich nicht -For Launcher, confirm that **Console Endpoint** is enabled. For the standalone binary, confirm that the process is still running and that `--console-enable true` is present. +Prüfen Sie bei Launcher, dass **Console Endpoint** aktiviert ist. Prüfen Sie bei der eigenständigen Binary, dass der Prozess noch läuft und `--console-enable true` gesetzt ist. -### Launcher reports an external RustFS process +### Launcher meldet einen externen RustFS-Prozess -Another process is listening on the configured API address, but Launcher did not start it. Stop that process or choose another API port. Launcher cannot stop a process it does not manage. +Ein anderer Prozess lauscht auf der konfigurierten API-Adresse, aber Launcher hat ihn nicht gestartet. Beenden Sie diesen Prozess oder wählen Sie einen anderen API-Port. Launcher kann einen Prozess nicht anhalten, den er nicht verwaltet. -### RustFS exits after launch +### RustFS beendet sich nach dem Start -In Launcher, inspect both the application and RustFS tabs in the built-in log viewer. For a standalone installation, inspect the Terminal output. Common causes include a missing data directory, insufficient permissions, an architecture mismatch, or a port conflict. +Prüfen Sie in Launcher beide Registerkarten, die der Anwendung und die von RustFS, in der integrierten Protokollanzeige. Prüfen Sie bei einer eigenständigen Installation die Terminal-Ausgabe. Häufige Ursachen sind ein fehlendes Datenverzeichnis, unzureichende Berechtigungen, eine abweichende Architektur oder ein Portkonflikt. -## Next steps +## Nächste Schritte -- Review the [S3 API guide](/administration/protocols/s3) before connecting a client. -- Learn how to [create a bucket](/administration/data/bucket/creation). -- See [status checks](/operations/status-check) for additional verification methods. -- Use the [Linux installation guides](/installation/linux) for a production-oriented deployment. +- Lesen Sie die [S3-API-Anleitung](/de/administration/protocols/s3), bevor Sie einen Client verbinden. +- Erfahren Sie, wie Sie [einen Bucket anlegen](/de/administration/data/bucket/creation). +- Weitere Prüfmöglichkeiten finden Sie unter [Statusprüfungen](/de/operations/status-check). +- Verwenden Sie die [Linux-Installationsanleitungen](/de/installation/linux) für eine auf den Produktivbetrieb ausgerichtete Bereitstellung. diff --git a/content/de/installation/requirement/checklists/hardware-checklists.md b/content/de/installation/requirement/checklists/hardware-checklists.md index 8250d5512..56245681d 100644 --- a/content/de/installation/requirement/checklists/hardware-checklists.md +++ b/content/de/installation/requirement/checklists/hardware-checklists.md @@ -1,93 +1,94 @@ --- -title: "Production Environment Hardware Configuration Guide" -description: "RustFS is a high-performance distributed object storage system developed in Rust, suitable for massive unstructured data storage scenarios. This document provides comprehensive hardware selection and configuration guidance for production environment deployment." +title: "Hardwareleitfaden für die Produktion" +description: "Diese Seite beschreibt die Bemessung und Konfiguration der Hardware für RustFS-Produktionsbereitstellungen." --- -## Deployment Planning Factor Analysis +## Planungsüberlegungen -Before formally deploying RustFS, it's recommended to conduct 2-3 weeks of business research, focusing on evaluating the following dimensions: +Bewerten Sie vor der Bereitstellung von RustFS in der Produktion über einen Zeitraum von zwei bis drei Wochen Ihre Arbeitslast und Ihren Kapazitätsbedarf. Konzentrieren Sie sich auf die folgenden Faktoren: -1. **Data Scale Analysis** +1. **Datenmenge** -- **Initial Data Volume**: Accurately calculate effective data volume at production startup (recommended in TiB units), considering hot/cold data ratios -- **Growth Trend Prediction**: Estimate data increments for the next 24 months based on business development plans (recommended quarterly growth rate model) -- **Object Scale**: Calculate total object count based on average object size (recommended 128 KB-1 MB range), note special optimization needed when exceeding 100 million objects + - **Anfängliche Datenmenge**: Schätzen Sie die nutzbare Datenmenge zum Produktivstart (in TiB), einschließlich des Verhältnisses von heißen zu kalten Daten. + - **Wachstumsprognose**: Schätzen Sie das Datenwachstum der nächsten 24 Monate anhand der Geschäftspläne. Wir empfehlen, das Wachstum quartalsweise zu modellieren. + - **Objektanzahl**: Schätzen Sie die Gesamtzahl der Objekte aus der durchschnittlichen Objektgröße (idealerweise 128 KB bis 1 MB). Bereitstellungen mit mehr als 100 Millionen Objekten brauchen zusätzliche Abstimmung. -2. **Business Characteristic Assessment** +2. **Eigenschaften der Arbeitslast** -- **Access Patterns**: Distinguish read-intensive (such as content distribution) from write-intensive (such as log collection) scenarios -- **Compliance Requirements**: Data retention cycles must comply with industry regulatory requirements (e.g., financial industry must retain for at least 5 years) -- **Multi-site Deployment**: Cross-regional deployment requires network latency assessment (recommended controlled within 50ms) and bandwidth cost evaluation + - **Zugriffsmuster**: Unterscheiden Sie leselastige Arbeitslasten (etwa Inhaltsverteilung) von schreiblastigen Arbeitslasten (etwa Protokollerfassung). + - **Einhaltung von Vorschriften**: Aufbewahrungsfristen müssen die Branchenvorschriften erfüllen (einige Finanzvorschriften verlangen beispielsweise eine Aufbewahrung von mindestens fünf Jahren). + - **Bereitstellung an mehreren Standorten**: Bewerten Sie bei regionsübergreifenden Bereitstellungen die Netzwerklatenz (idealerweise unter 50 ms) und die Bandbreitenkosten. -3. **Storage Architecture Design** +3. **Speicherarchitektur** -- **Bucket Planning**: Divide storage buckets by business units, single cluster recommended not exceeding 500 active buckets -- **Disaster Recovery Strategy**: Choose dual-active architecture (recommended) or asynchronous replication based on data importance + - **Bucket-Planung**: Organisieren Sie Buckets nach Geschäftseinheit. Wir empfehlen höchstens 500 aktive Buckets je Cluster. + - **Notfallwiederherstellung**: Wählen Sie Aktiv-Aktiv-Replikation (empfohlen) oder asynchrone Replikation, je nachdem, wie kritisch die Daten sind. -## Hardware Configuration Matrix +## Hardware-Konfigurationsmatrix -Baseline configuration solutions based on stress test results: +Basiskonfigurationen auf Grundlage von Lasttestergebnissen: -| Component | Basic Environment | Production Standard Configuration | High-Performance Configuration | -|--------------|---------------------------|--------------------------|--------------------------| -| Node Count | 4 nodes | 8 nodes | 16+ nodes | -| Storage Media | 4× NVMe SSD | 8×NVMe SSD | 12×NVMe SSD | -| Network Architecture | Dual 25GbE (link aggregation) | Dual 100GbE | 200GbE | -| CPU | 2×Intel Silver 4310 (16 cores) | 2×AMD EPYC 7313 (32 cores) | 2×Intel Platinum 8461Y (48 cores) | -| Memory | 64 GB DDR4-3200 ECC | 256 GB DDR5-4800 ECC | 512 GB DDR5-5600 ECC | -| Storage Controller | HBA 9500-8i | HBA 9600-16i | Dual controller redundant architecture | +| Komponente | Einstieg | Produktionsstandard | Hohe Leistung | +| --- | --- | --- | --- | +| Knotenanzahl | 4 Knoten | 8 Knoten | 16 oder mehr Knoten | +| Speichermedium | 4× NVMe-SSD | 8× NVMe-SSD | 12× NVMe-SSD | +| Netzwerkarchitektur | 2× 25GbE (Link-Aggregation) | 2× 100GbE | 200GbE | +| CPU | 2×Intel Silver 4310 (16 Kerne) | 2×AMD EPYC 7313 (32 Kerne) | 2×Intel Platinum 8461Y (48 Kerne) | +| Arbeitsspeicher | 64 GB DDR4-3200 ECC | 256 GB DDR5-4800 ECC | 512 GB DDR5-5600 ECC | +| Speichercontroller | HBA 9500-8i | HBA 9600-16i | Redundante Architektur mit zwei Controllern | -**Important Deployment Principles:** +**Bereitstellungsrichtlinien:** -1. Adopt "server farm" mode, ensuring all nodes use identical hardware batches and firmware versions -2. Network architecture must meet: leaf-spine topology + physically isolated storage network + dual uplink paths -3. Recommend using 2U server models, single node recommended configuration of 12+ disk bays (based on actual hard disk count) +1. Verwenden Sie homogene Knoten: Jeder Knoten sollte identische Hardware aus derselben Charge und dieselben Firmware-Versionen aufweisen. +2. Das Netzwerk muss eine Leaf-Spine-Topologie, ein physisch getrenntes Speichernetz und zwei Uplink-Verbindungen verwenden. +3. Wir empfehlen 2U-Server mit mindestens 12 Laufwerksschächten je Knoten, abhängig von der benötigten Anzahl der Datenträger. -## Performance Critical Path Optimization +## Leistungsoptimierung -### Network Topology Optimization (Highest Priority) +### Optimierung der Netzwerktopologie (höchste Priorität) -- **Bandwidth Calculation**: Reserve 0.5 Gbps bandwidth per TB of effective data (e.g., 100 TB data needs 50 Gbps dedicated bandwidth) -- **Latency Requirements**: -- Inter-node P99 latency ≤ 2ms -- Cross-rack latency ≤ 5ms +- **Bandbreitenbemessung**: Planen Sie 0,5 Gbps Bandbreite je TB nutzbarer Daten ein (100 TB Daten benötigen beispielsweise 50 Gbps dedizierte Bandbreite). +- **Latenzanforderungen**: + - P99-Latenz zwischen Knoten ≤ 2 ms + - Latenz zwischen Racks ≤ 5 ms -### Storage Subsystem Tuning +### Abstimmung des Speichersubsystems -- **Controller Configuration**: -- Enable read-ahead cache (recommended 256 MB+) -- Disable all RAID functions, use pass-through mode -- Regularly check BBU battery health status -- **SSD Parameters**: -- Reserve 20% OP space to improve durability -- Enable atomic write features (requires hardware support) +- **Controller-Konfiguration**: + - Aktivieren Sie den Vorauslese-Cache (mindestens 256 MB empfohlen). + - Deaktivieren Sie alle RAID-Funktionen und verwenden Sie den Durchleitungsmodus (HBA/JBOD). + - Prüfen Sie den Zustand der BBU regelmäßig. +- **SSD-Parameter**: + - Reservieren Sie 20 % Überprovisionierung (OP), um die Lebensdauer zu verbessern. + - Aktivieren Sie atomare Schreibvorgänge (erfordert Hardwareunterstützung). -### Memory Management Strategy +### Arbeitsspeicherzuweisung -- **Allocation Ratios**: -- Metadata cache: 60% of total memory -- Read/write buffers: 30% -- System reserve: 10% +- **Zuweisungsverhältnisse**: + - Metadaten-Cache: 60 % des gesamten Arbeitsspeichers + - Lese- und Schreibpuffer: 30 % + - Systemreserve: 10 % -## Network Design Reference Model +## Referenzmodell für das Netzwerkdesign -### Bandwidth and Disk Ratio Relationship +### Netzwerkbandbreite und Datenträgeranzahl -| Network Type | Theoretical Throughput | Suitable Disk Types | Maximum Disk Support | -|------------|------------|---------------------|----------------| -| 10GbE | 1.25 GB/s | 7.2K HDD (180 MB/s) | 8 disks | -| 25GbE | 3.125 GB/s | SATA SSD (550 MB/s) | 6 disks | -| 100GbE | 12.5 GB/s | NVMe Gen4 (7 GB/s) | 2 disks full-speed read/write | +| Netzwerk | Theoretischer Durchsatz | Datenträgertyp | Maximale Datenträger je Knoten | +| --- | --- | --- | --- | +| 10GbE | 1,25 GB/s | 7.2K HDD (180 MB/s) | 8 Datenträger | +| 25GbE | 3,125 GB/s | SATA-SSD (550 MB/s) | 6 Datenträger | +| 100GbE | 12,5 GB/s | NVMe Gen4 (7 GB/s) | 2 (bei voller Lese- und Schreibgeschwindigkeit) | -**Best Practice Case**: A video platform uses 16-node cluster, each node configured with: +**Beispiel**: Eine Videoplattform betreibt einen Cluster mit 16 Knoten. Jeder Knoten verfügt über: -- 8×7.68 TB NVMe SSD -- Dual 100GbE CX5 network cards -- Achieves aggregate throughput of 38 GB/s +- 8×7,68 TB NVMe-SSD +- zwei NVIDIA ConnectX-5-NICs mit 100GbE -## Memory Configuration Calculator +Der Cluster erreicht einen aggregierten Durchsatz von 38 GB/s. -Dynamic algorithm based on disk capacity and business characteristics: +## Bemessung des Arbeitsspeichers + +Bemessen Sie den Arbeitsspeicher anhand der Datenträgerkapazität und des Lasttyps mit der folgenden Formel: ```python # Memory calculation formula (unit: GB) @@ -101,25 +102,25 @@ def calc_memory(data_tb, access_pattern): return base + data_tb * 1.0 ``` -**Reference Configuration Table**: +**Referenzgrößen**: -| Data Scale | Read-Intensive | Write-Intensive | Mixed | -|-----------|----------|----------|---------| +| Datenmenge | Leselastig | Schreiblastig | Gemischt | +| --- | --- | --- | --- | | 10 TB | 40 GB | 44 GB | 42 GB | | 100 TB | 112 GB | 152 GB | 132 GB | | 500 TB | 432 GB | 632 GB | 532 GB | -## Storage Deployment Standards +## Speicherrichtlinien -### Media Selection Criteria +### Speichermedien auswählen -| Metric | HDD Suitable Scenarios | SSD Suitable Scenarios | NVMe Mandatory Scenarios | -|-------------|------------------|---------------------|----------------------| -| Latency Requirements | >50ms | 1 to 10ms | < 1ms | -| Throughput Requirements | < 500 MB/s | 500 MB-3 GB/s | > 3 GB/s | -| Typical Use Cases | Archive storage | Hot data cache | Real-time analysis | +| Metrik | HDD | SATA-SSD | NVMe (erforderlich) | +| --- | --- | --- | --- | +| Latenzanforderungen | > 50 ms | 1 bis 10 ms | < 1 ms | +| Durchsatzanforderungen | < 500 MB/s | 500 MB/s bis 3 GB/s | > 3 GB/s | +| Typische Anwendungsfälle | Archivspeicher | Cache für heiße Daten | Echtzeitanalysen | -### File System Configuration +### Dateisystemkonfiguration ```bash # XFS formatting example @@ -129,30 +130,34 @@ mkfs.xfs -f -L rustfs_disk1 -d su=256k,sw=10 /dev/sdb UUID=xxxx /mnt/disk1 xfs defaults,noatime,nodiratime,logbsize=256k 0 0 ``` -## High Availability Assurance Measures +## Hochverfügbarkeit + +1. **Stromversorgung**: + + - Verwenden Sie doppelte (redundante) Netzteile. + - Schließen Sie jede PDU an eine eigene Einspeisung an. + - Sehen Sie eine USV mit mindestens 30 Minuten Überbrückungszeit vor. + +2. **Kühlungsanforderungen**: -1. **Power Supply**: + - Leistungsdichte im Rack ≤ 15 kW je Rack. + - Halten Sie die Temperaturdifferenz zwischen Einlass und Auslass (ΔT) bei höchstens 8 °C. -- Adopt dual power supply architecture -- Each PDU connects to different substations -- Equip UPS (at least 30 minutes runtime) +3. **Firmware-Verwaltung**: -2. **Cooling Requirements**: + - Pflegen Sie eine Hardware-Kompatibilitätsmatrix. + - Vereinheitlichen Sie die Firmware-Versionen auf allen Knoten. -- Cabinet power density ≤ 15kW/cabinet -- Inlet/outlet temperature difference controlled within 8℃ +:::tip[Vor der Produktivsetzung] -3. **Firmware Management**: +Wir empfehlen, vor der Produktivsetzung einen 72-Stunden-Stresstest durchzuführen, der die folgenden Szenarien abdeckt: -- Establish hardware compatibility matrix -- Use unified firmware versions +1. Test beim Ausfall eines Knotens +2. Tests zur Netzwerkpartition +3. Lasttests mit Schreibspitzen (wir empfehlen einen Test mit 120 % des theoretischen Maximums) -> **Implementation Recommendations**: Recommend conducting 72-hour stress testing before formal deployment, simulating the following scenarios: -> -> 1. Node failover testing -> 2. Network partition drills -> 3. Burst write pressure testing (recommended reaching 120% of theoretical value) +::: --- -This guide is based on the latest RustFS development version. For actual deployment, please combine with specific hardware vendor white papers for parameter fine-tuning. Or contact RustFS official recommendations for quarterly hardware health assessments to ensure continuous stable operation of storage clusters. +Diese Anleitung basiert auf der neuesten Entwicklungsversion von RustFS. Stimmen Sie diese Einstellungen für Produktionsbereitstellungen anhand der Dokumentation Ihres Hardwareherstellers ab. Wenden Sie sich für vierteljährliche Bewertungen des Hardwarezustands an RustFS. diff --git a/content/de/installation/requirement/checklists/hardware-selection.md b/content/de/installation/requirement/checklists/hardware-selection.md index f10dae4c7..996359a44 100644 --- a/content/de/installation/requirement/checklists/hardware-selection.md +++ b/content/de/installation/requirement/checklists/hardware-selection.md @@ -1,41 +1,41 @@ --- -title: Hardware Selection -description: Hardware requirements for RustFS. +title: "Hardwareauswahl" +description: "Diese Seite listet die minimale und die empfohlene Hardware für Test- und Produktionsumgebungen von RustFS auf." --- -> RustFS is designed for efficiency with a low memory footprint. +> RustFS ist auf Effizienz bei geringem Arbeitsspeicherbedarf ausgelegt. -## Test Environment +## Testumgebung -> Minimal requirements for testing: +Mindestanforderungen für Tests: -| Component | Requirement | +| Komponente | Anforderung | | - | - | -| CPU | 1 core+ | -| Architecture | x86, ARM | -| Memory | 1 GB+ | -| Storage | HDD or SSD | -| Docker | Supported | -| Network | Local or Offline | -| OS | Windows, Linux, macOS | -| Load Balancing | None | -| Nodes | 1 | +| CPU | mindestens 1 Kern | +| Architektur | x86, ARM | +| Arbeitsspeicher | mindestens 1 GB | +| Speicher | HDD oder SSD | +| Docker | Unterstützt | +| Netzwerk | Lokal oder offline | +| Betriebssystem | Windows, Linux, macOS | +| Lastverteilung | Keine | +| Knoten | 1 | -## Production Environment +## Produktionsumgebung -Die Windows-Version von RustFS ist ausschließlich für Entwicklung und Debugging vorgesehen und wird **nicht für Produktionsumgebungen empfohlen**. Für Produktionsumgebungen empfehlen wir [Linux](/de/installation/linux). +Die Windows-Version von RustFS ist ausschließlich für Entwicklung und Fehlersuche vorgesehen und wird **nicht für Produktionsbereitstellungen empfohlen**. Wir empfehlen [Linux](/de/installation/linux) für Produktionslasten. -| Component | Requirement | +| Komponente | Anforderung | | - | - | -| CPU | 2 x 12 cores+ | -| Architecture | x86, ARM, etc. | -| Memory | 64 GB+ | -| Storage | SSD recommended | -| Network | 10 Gbps+ | -| OS | Linux (Recommended) | -| Load Balancing | Recommended | -| Nodes | 4+ | - -## Expert Services - -For complex deployments, contact support at hello@rustfs.com. +| CPU | 2 × 12 Kerne oder mehr | +| Architektur | x86, ARM usw. | +| Arbeitsspeicher | mindestens 64 GB | +| Speicher | SSD empfohlen | +| Netzwerk | mindestens 10 Gbps | +| Betriebssystem | Linux (empfohlen) | +| Lastverteilung | Empfohlen | +| Knoten | mindestens 4 | + +## Professionelle Dienste + +Wenden Sie sich bei komplexen Bereitstellungen an den Support unter hello@rustfs.com. diff --git a/content/de/installation/requirement/checklists/index.md b/content/de/installation/requirement/checklists/index.md index 7b1f73a8b..e9e76c17c 100644 --- a/content/de/installation/requirement/checklists/index.md +++ b/content/de/installation/requirement/checklists/index.md @@ -1,24 +1,24 @@ --- -title: "Checklist" -description: "Pre-installation checklists." +title: "Checklisten vor der Installation" +description: "Diese Seite enthält die Checklisten vor der Installation." --- -These checklists cover the necessary preparations for a production environment. +Diese Checklisten decken die notwendigen Vorbereitungen für eine Produktionsumgebung ab. :::note -These are general guidelines. Adjust them based on your specific architecture and requirements. +Dies sind allgemeine Richtlinien. Passen Sie sie an Ihre konkrete Architektur und Ihre Anforderungen an. ::: -For professional support, contact us at hello@rustfs.com. +Für professionellen Support schreiben Sie an hello@rustfs.com. -For community support, submit an issue on GitHub. +Für Support aus der Community öffnen Sie auf GitHub ein Issue. -## Checklist +## Checkliste -- [Hardware Checklist](./hardware-checklists.md) -- [Hardware Selection](./hardware-selection.md) -- [Security Checklist](./security-checklists.md) -- [Software Checklist](./software-checklists.md) -- [Network Checklist](./network-checklists.md) +- [Hardware-Checkliste](./hardware-checklists.md) +- [Hardwareauswahl](./hardware-selection.md) +- [Sicherheits-Checkliste](./security-checklists.md) +- [Software-Checkliste](./software-checklists.md) +- [Netzwerk-Checkliste](./network-checklists.md) diff --git a/content/de/installation/requirement/checklists/network-checklists.md b/content/de/installation/requirement/checklists/network-checklists.md index 8f77cd5ad..99ee38aff 100644 --- a/content/de/installation/requirement/checklists/network-checklists.md +++ b/content/de/installation/requirement/checklists/network-checklists.md @@ -1,49 +1,49 @@ --- -title: "Network Checklist" -description: "Network checklist for enterprise deployments." +title: "Netzwerk-Checkliste" +description: "Diese Checkliste fasst die Netzwerkanforderungen für Unternehmensbereitstellungen zusammen." --- -## Network Architecture +## Netzwerkarchitektur -### Planning +### Planung -- **Topology** - Verify the architecture (star/ring/mesh) meets high availability requirements. -- **Redundancy** - Ensure at least two independent physical links between nodes. -- **Bandwidth** - Calculate estimated traffic: object storage read/write bandwidth × node count × replica count + 20% redundancy. +- **Topologie** + Prüfen Sie, ob die Architektur (Stern, Ring oder vermascht) die Anforderungen an die Hochverfügbarkeit erfüllt. +- **Redundanz** + Stellen Sie mindestens zwei unabhängige physische Verbindungen zwischen den Knoten sicher. +- **Bandbreite** + Schätzen Sie den Datenverkehr als Lese- und Schreibbandbreite × Knotenanzahl × Replikatanzahl und rechnen Sie 20 % Spielraum hinzu. -### IP Allocation +### IP-Zuweisung -- [ ] Separate management network from data network. -- [ ] Allocate continuous IP segments for storage nodes (recommend /24 subnet). -- [ ] Reserve at least 15% of IP addresses for expansion. +- [ ] Trennen Sie das Verwaltungsnetz vom Datennetz. +- [ ] Weisen Sie den Speicherknoten einen zusammenhängenden IP-Adressbereich zu. Wir empfehlen ein /24-Subnetz. +- [ ] Reservieren Sie mindestens 15 % der IP-Adressen für die Erweiterung. --- -## Hardware Requirements +## Hardwareanforderungen ### Switches -| Check Item | Requirements | -|--------|---------| -| Backplane Bandwidth | ≥ Full port line rate forwarding capability × 1.2 | -| Port Type | 10G/25G/100G SFP+/QSFP+ fiber ports | -| Flow Table Capacity | ≥ Node count × 5 | -| Spanning Tree | Enable RSTP/MSTP fast convergence | +| Punkt | Anforderung | +| --- | --- | +| Backplane-Bandbreite | ≥ 1,2 × aggregierte Leitungsrate aller Ports | +| Porttyp | Glasfaserports 10G/25G/100G SFP+/QSFP+ | +| Kapazität der Flow-Tabelle | ≥ Knotenanzahl × 5 | +| Spanning Tree | Aktivieren Sie RSTP oder MSTP für schnelle Konvergenz | -### Cabling +### Verkabelung -- [ ] Fiber attenuation test (single mode ≤0.35dB/km). -- [ ] Port misalignment check (Node A eth0 ↔ Node B eth0). -- [ ] Cable labeling (including source/destination IP + port number). +- [ ] Dämpfungstest der Glasfaser (Singlemode ≤ 0,35 dB/km). +- [ ] Prüfen Sie die Portzuordnung (Knoten A eth0 ↔ Knoten B eth0). +- [ ] Kabelbeschriftung (einschließlich Quell- und Ziel-IP sowie Portnummer). --- -## OS Configuration +## Konfiguration des Betriebssystems -### Kernel Tuning +### Kernel-Abstimmung ```bash # Check the following parameter settings @@ -53,15 +53,15 @@ net.ipv4.tcp_keepalive_time = 600 net.ipv4.tcp_slow_start_after_idle = 0 ``` -### NIC Configuration +### NIC-Konfiguration -- [ ] Enable jumbo frames (MTU=9000, requires full path support). -- [ ] Verify bonding mode (recommend LACP mode4). -- [ ] Disable IPv6 (if not needed). +- [ ] Aktivieren Sie Jumbo-Frames (MTU=9000, Unterstützung auf dem gesamten Pfad erforderlich). +- [ ] Prüfen Sie den Bonding-Modus. Wir empfehlen LACP mode4. +- [ ] Deaktivieren Sie IPv6 (falls nicht benötigt). --- -## Security +## Sicherheit ### Firewall @@ -72,43 +72,43 @@ net.ipv4.tcp_slow_start_after_idle = 0 - TCP 443 (only if you terminate HTTPS on a reverse proxy / load balancer) ``` -### Access Control +### Zugriffskontrolle -- Switch port security MAC restrictions. -- IPSec tunnel encryption between storage nodes. -- Enable TLS 1.3 for management interfaces. +- Aktivieren Sie auf den Switches die Portsicherheit (Begrenzung der MAC-Adressen). +- Verschlüsseln Sie den Datenverkehr zwischen den Speicherknoten mit IPsec. +- Aktivieren Sie TLS 1.3 für die Verwaltungsschnittstellen. --- -## Performance Testing +## Leistungstests -### Benchmarks +### Referenzmessungen -1. Inter-node latency: `ping -c 20 ` (run `iperf3 -s` on the target first for throughput tests) -2. Cross-rack bandwidth: `iperf3 -c -P 8 -t 30` -3. Failover: Randomly disconnect core links to observe recovery time. +1. Latenz zwischen Knoten: `ping -c 20 ` (führen Sie für Durchsatztests zuerst `iperf3 -s` auf dem Ziel aus) +2. Bandbreite zwischen Racks: `iperf3 -c -P 8 -t 30` +3. Ausfallübernahme: Trennen Sie Kernverbindungen nach dem Zufallsprinzip und beobachten Sie die Wiederherstellungszeit. -### Criteria +### Kriterien -| Metric | Requirements | -|------|------| -| Node Latency | ≤1ms (same room) / ≤5ms (cross AZ) | -| Bandwidth Utilization | Peak ≤70% of design capacity | -| Failover | < 500ms BPDU convergence | +| Metrik | Anforderungen | +| --- | --- | +| Knotenlatenz | ≤ 1 ms (dasselbe Rechenzentrum) / ≤ 5 ms (über Verfügbarkeitszonen hinweg) | +| Bandbreitenauslastung | Spitze ≤ 70 % der Auslegungskapazität | +| Ausfallübernahme | < 500 ms BPDU-Konvergenz | --- -## Documentation Requirements +## Dokumentationsanforderungen -1. Network topology diagram (including physical connections and logical IPs) -2. Switch configuration backup files (with timestamps) -3. Baseline test reports (including raw data) -4. Change record table (including maintenance window information) +1. Netzwerktopologiediagramm (einschließlich physischer Verbindungen und logischer IP-Adressen) +2. Sicherungsdateien der Switch-Konfiguration (mit Zeitstempeln) +3. Berichte der Basismessung (einschließlich Rohdaten) +4. Änderungsprotokoll (einschließlich Wartungsfenster) :::tip -Recommend conducting 72-hour stress testing before formal deployment, simulating 110% peak traffic load scenarios +Wir empfehlen, vor der Bereitstellung in der Produktion einen 72-Stunden-Stresstest mit 110 % des erwarteten Spitzenverkehrs durchzuführen. ::: -This checklist covers key checkpoints for enterprise storage system network deployment, specifically optimized parameter requirements for distributed object storage characteristics. You can contact RustFS for official technical support. +Diese Checkliste deckt die wesentlichen Netzwerkanforderungen für die Bereitstellung von verteiltem Objektspeicher in einer Unternehmensumgebung ab. Wenden Sie sich für technischen Support an RustFS. diff --git a/content/de/installation/requirement/checklists/security-checklists.md b/content/de/installation/requirement/checklists/security-checklists.md index 5024450ed..a8aea1107 100644 --- a/content/de/installation/requirement/checklists/security-checklists.md +++ b/content/de/installation/requirement/checklists/security-checklists.md @@ -1,78 +1,78 @@ --- -title: "Security Checklist" -description: "Security checklist for enterprise deployments." +title: "Sicherheits-Checkliste" +description: "Diese Checkliste fasst die Sicherheitsanforderungen für Unternehmensbereitstellungen zusammen." --- -> Security best practices for RustFS. Review this checklist during deployment to ensure system security and reliability. +> Bewährte Sicherheitspraktiken für RustFS. Prüfen Sie diese Checkliste während der Bereitstellung, damit das System sicher und zuverlässig bleibt. -## Authentication & Access Control +## Authentifizierung und Zugriffskontrolle -- **Use S3-Compatible Key Authentication** - RustFS uses AWS Signature V4. Ensure all requests are authenticated with valid Access Keys and Secret Keys. +- **S3-kompatible Schlüsselauthentifizierung verwenden** + RustFS verwendet AWS Signature V4. Stellen Sie sicher, dass alle Anfragen mit einem gültigen Zugriffsschlüssel und einem gültigen geheimen Zugriffsschlüssel signiert sind. -- **Policy-Based Access Control** - Define access policies based on the principle of least privilege. Explicitly define allowed operations; deny all others by default. +- **Richtlinienbasierte Zugriffskontrolle** + Definieren Sie Zugriffsrichtlinien nach dem Prinzip der geringsten Berechtigung. Legen Sie erlaubte Operationen ausdrücklich fest und verweigern Sie alle übrigen standardmäßig. -## Encryption (TLS/SSL) +## Verschlüsselung (TLS/SSL) -- **Enable TLS/SSL** - Configure valid SSL certificates. We recommend using different certificates for external and internal access, and enforcing TLS 1.2+. +- **TLS/SSL aktivieren** + Konfigurieren Sie gültige TLS-Zertifikate. Wir empfehlen, für den externen und den internen Zugriff unterschiedliche Zertifikate zu verwenden und TLS 1.2+ zu erzwingen. -- **Certificate Management** - Use certificates from trusted CAs. Protect private keys with strict file permissions. +- **Zertifikatsverwaltung** + Verwenden Sie Zertifikate vertrauenswürdiger CAs. Schützen Sie die privaten Schlüssel durch strikte Dateiberechtigungen. -- **Multi-Domain and Cipher Suites** - Configure independent certificates for multiple domains. Use strong encryption algorithms (e.g., 2048-bit RSA or 256-bit ECC). +- **Mehrere Domänen und Verschlüsselungssuiten** + Verwenden Sie für jede Domäne ein eigenes Zertifikat. Verwenden Sie starke Schlüsselalgorithmen (zum Beispiel RSA mit 2048 Bit oder ECDSA P-256). -## Credential Protection +## Schutz der Zugangsdaten -- **Change Default Credentials** - Never keep the example placeholders (`` / ``) in production. Set a unique access key and a strong, random secret — e.g. generate one with `openssl rand -base64 24` — immediately after initialization. +- **Standardzugangsdaten ändern** + Belassen Sie die Beispielplatzhalter (`` / ``) niemals in der Produktion. Legen Sie unmittelbar nach der Initialisierung einen eindeutigen Zugriffsschlüssel und einen starken, zufälligen geheimen Zugriffsschlüssel fest — erzeugen Sie einen zum Beispiel mit `openssl rand -base64 24`. -- **Secure Storage** - Do not hardcode credentials. Use environment variables or secrets management systems (e.g., Kubernetes Secrets). +- **Sichere Ablage** + Hinterlegen Sie Zugangsdaten nicht fest im Code. Verwenden Sie Umgebungsvariablen oder eine Geheimnisverwaltung (zum Beispiel Kubernetes Secrets). -## Logging & Auditing +## Protokollierung und Audit -- **Enable Audit Logs** - Export audit logs to external systems (HTTP Webhook, Kafka, ELK, Splunk). +- **Audit-Protokolle aktivieren** + Exportieren Sie Audit-Protokolle in externe Systeme (HTTP-Webhook, Kafka, ELK, Splunk). -- **Log Collection** - Collect logs using standard tools (systemd, Docker, K8s) and analyze with ELK or Grafana Loki. +- **Protokollerfassung** + Erfassen Sie Protokolle mit Standardwerkzeugen (journald, Docker, Kubernetes) und werten Sie sie mit ELK oder Grafana Loki aus. -- **Monitoring and Alerts** - Set alerts for abnormal behavior (login failures, unusual access patterns, mass deletions). +- **Überwachung und Alarme** + Richten Sie Alarme für auffälliges Verhalten ein (fehlgeschlagene Anmeldungen, ungewöhnliche Zugriffsmuster, Massenlöschungen). - **Observability** - Monitor function execution times to optimize performance. + Überwachen Sie die Anfragelatenz, um Leistungsprobleme zu erkennen. -## API Security +## API-Sicherheit -- **Restrict Network Access** - Restrict access to the S3 API (port 9000) and Console (port 9001) using firewalls or security groups. +- **Netzwerkzugriff einschränken** + Schränken Sie den Zugriff auf die S3-API (Port 9000) und die Console (Weboberfläche, Port 9001) mit Firewalls oder Sicherheitsgruppen ein. -- **Network Isolation** - Use reverse proxies (e.g., Nginx) instead of exposing storage nodes directly. +- **Netzwerkisolierung** + Verwenden Sie Reverse-Proxys (zum Beispiel Nginx), statt die Speicherknoten direkt offenzulegen. -- **Close Unnecessary Ports** - Disable unused ports and do not expose management interfaces to the public internet. +- **Unnötige Ports schließen** + Deaktivieren Sie ungenutzte Ports und legen Sie Verwaltungsschnittstellen nicht im öffentlichen Internet offen. -## WORM Compliance +## WORM-Konformität -- **Version Control and Object Locking** - Enable versioning and object locking to meet regulatory requirements. +- **Versionierung und Object Lock** + Aktivieren Sie die Versionierung und Object Lock, um aufsichtsrechtliche Anforderungen zu erfüllen. -## Updates +## Aktualisierungen -- **Apply Patches** - Regularly check for and apply RustFS updates. +- **Patches einspielen** + Prüfen Sie regelmäßig auf Aktualisierungen von RustFS und spielen Sie sie ein. -- **Non-Disruptive Upgrades** - Use the rolling restart process for zero-downtime upgrades. +- **Unterbrechungsfreie Upgrades** + Verwenden Sie den fortlaufenden Neustart (Rolling Restart) für Upgrades ohne Ausfallzeit. -- **OS and Dependencies** - Keep the operating system and dependencies (e.g., OpenSSL) updated. +- **Betriebssystem und Abhängigkeiten** + Halten Sie das Betriebssystem und die Abhängigkeiten (zum Beispiel OpenSSL) aktuell. --- -Review this checklist regularly to maintain a secure RustFS deployment. +Prüfen Sie diese Checkliste regelmäßig, um eine sichere RustFS-Bereitstellung aufrechtzuerhalten. diff --git a/content/de/installation/requirement/checklists/software-checklists.md b/content/de/installation/requirement/checklists/software-checklists.md index d2ed35b81..9b7280c09 100644 --- a/content/de/installation/requirement/checklists/software-checklists.md +++ b/content/de/installation/requirement/checklists/software-checklists.md @@ -1,50 +1,50 @@ --- -title: "Software Checklist" -description: "Software requirements and considerations." +title: "Software-Checkliste" +description: "Diese Seite beschreibt die Softwareanforderungen und die zugehörigen Hinweise." --- -Ensure the following requirements are met before deployment. +Stellen Sie vor der Bereitstellung sicher, dass die folgenden Anforderungen erfüllt sind. -## OS Requirements +## Anforderungen an das Betriebssystem -- **Operating System**: Use LTS versions (Ubuntu 20.04+, RHEL 8/9). -- **Kernel**: Linux 5.x+ is recommended. -- **CPU & Memory**: x86_64 or ARM. Minimum 2 GB RAM for testing, 64 GB+ for production. -- **Disable Interfering Services**: Disable file indexing and auditing services (e.g., `mlocate`, `auditd`, antivirus) to prevent I/O interference. +- **Betriebssystem**: Verwenden Sie LTS-Versionen (Ubuntu 20.04+, RHEL 8/9). +- **Kernel**: Linux 5.x+ wird empfohlen. +- **CPU und Arbeitsspeicher**: x86_64 oder ARM. Mindestens 2 GB RAM für Tests, mindestens 64 GB für die Produktion. +- **Störende Dienste deaktivieren**: Deaktivieren Sie Dienste zur Dateiindizierung und zur Auditierung (zum Beispiel `mlocate`, `auditd`, Virenschutz), damit sie die I/O nicht stören. -> **Why Linux 5.x+?** -> Modern LTS kernels bring mature async I/O and filesystem improvements. RustFS also offers an optional `io_uring` read path (`RUSTFS_IO_URING_READ_ENABLE`, disabled by default), which requires Linux 5.10+ to be effective. +> **Warum Linux 5.x+?** +> Aktuelle LTS-Kernel bringen ausgereiftes asynchrones I/O und Verbesserungen des Dateisystems mit. RustFS bietet zusätzlich einen optionalen Lesepfad über `io_uring` (`RUSTFS_IO_URING_READ_ENABLE`, standardmäßig deaktiviert), der Linux 5.10 oder neuer voraussetzt, um wirksam zu sein. -## Binary Deployment +## Bereitstellung der Binärdatei -- **Official Download**: Download binaries only from official RustFS channels. -- **Integrity Verification**: Verify SHA256 checksums. -- **Consistency**: Ensure all nodes run the same RustFS version. -- **Installation Location**: Place binaries in `/usr/local/bin` and ensure they are executable (`chmod +x`). +- **Offizielle Bezugsquelle**: Laden Sie Binärdateien nur über die offiziellen Kanäle von RustFS herunter. +- **Prüfsummenprüfung**: Prüfen Sie die SHA256-Prüfsummen. +- **Einheitlichkeit**: Stellen Sie sicher, dass alle Knoten dieselbe RustFS-Version ausführen. +- **Installationsort**: Legen Sie die Binärdateien unter `/usr/local/bin` ab und stellen Sie sicher, dass sie ausführbar sind (`chmod +x`). -## File System & Disks +## Dateisystem und Datenträger -- **Dedicated Data Disks**: Use dedicated disks for RustFS data. Do not share with the OS. -- **File System**: Use XFS or Ext4 with performance options (e.g., `noatime`). -- **Disk Configuration**: Use JBOD (independent volumes). Do not use hardware RAID. -- **Permissions**: Ensure the RustFS user has read/write access to data directories. +- **Dedizierte Speicherdatenträger**: Verwenden Sie dedizierte Datenträger für RustFS-Daten. Teilen Sie sie nicht mit dem Betriebssystem. +- **Dateisystem**: Verwenden Sie XFS oder ext4 mit leistungsorientierten Einhängeoptionen wie `noatime`. +- **Datenträgerkonfiguration**: Verwenden Sie JBOD (unabhängige Volumes). Verwenden Sie kein Hardware-RAID. +- **Berechtigungen**: Stellen Sie sicher, dass der RustFS-Benutzer Lese- und Schreibzugriff auf die Datenverzeichnisse hat. -## Dependencies +## Abhängigkeiten -- **Time Synchronization**: Synchronize time across all nodes using `ntp` or `chrony`. -- **Hostname and DNS**: Configure persistent hostnames and ensure proper DNS resolution. -- **Network Connectivity**: Ensure all nodes can communicate on the RustFS port (default 9000). -- **TLS/Certificates**: Install root certificates and prepare server certificates if using HTTPS. -- **Packages**: Ensure standard tools (`bash`, `glibc`, `openssl`) are installed. +- **Zeitsynchronisation**: Synchronisieren Sie die Uhrzeit auf allen Knoten mit `ntp` oder `chrony`. +- **Hostname und DNS**: Konfigurieren Sie dauerhafte Hostnamen und stellen Sie eine korrekte DNS-Auflösung sicher. +- **Netzwerkverbindung**: Stellen Sie sicher, dass alle Knoten über den RustFS-Port kommunizieren können (Standard 9000). +- **TLS und Zertifikate**: Installieren Sie Stammzertifikate und bereiten Sie Serverzertifikate vor, wenn Sie HTTPS verwenden. +- **Pakete**: Stellen Sie sicher, dass die Standardwerkzeuge (`bash`, `glibc`, `openssl`) installiert sind. -## User & Security +## Benutzer und Sicherheit -- **Dedicated User**: Run RustFS as a dedicated user (e.g., `rustfs-user`). -- **File Permissions**: Restrict access to binaries and configuration files. -- **SELinux/AppArmor**: Configure policies to allow RustFS operations, or disable if appropriate. -- **Systemd**: Configure the systemd service file correctly (`User=`, `ExecStart=`, environment variables). +- **Dedizierter Benutzer**: Führen Sie RustFS unter einem dedizierten Benutzer aus (zum Beispiel `rustfs-user`). +- **Dateiberechtigungen**: Schränken Sie den Zugriff auf Binärdateien und Konfigurationsdateien ein. +- **SELinux/AppArmor**: Konfigurieren Sie Richtlinien, die RustFS-Operationen erlauben, oder deaktivieren Sie sie, wenn das angemessen ist. +- **systemd**: Konfigurieren Sie die systemd-Dienstdatei korrekt (`User=`, `ExecStart=`, Umgebungsvariablen). -## Other +## Weiteres -- **Monitoring**: Configure Prometheus and Grafana. -- **Rollback Plan**: Prepare configuration backups and a rollback plan. +- **Überwachung**: Konfigurieren Sie Prometheus und Grafana. +- **Rücknahmeplan**: Bereiten Sie Sicherungen der Konfiguration und einen Rücknahmeplan vor. diff --git a/content/de/installation/requirement/disk-preparation.md b/content/de/installation/requirement/disk-preparation.md index e8fed45d8..78d070994 100644 --- a/content/de/installation/requirement/disk-preparation.md +++ b/content/de/installation/requirement/disk-preparation.md @@ -1,83 +1,83 @@ --- -title: "Disk Preparation" -description: "Identify, format, mount, and verify dedicated data disks before installing RustFS on Linux." +title: "Datenträgervorbereitung" +description: "Diese Seite beschreibt, wie Sie dedizierte Speicherdatenträger vor der Installation von RustFS unter Linux identifizieren, formatieren, einhängen und prüfen." --- -Prepare each RustFS data disk as an independent XFS file system with a stable label and mount point. Complete these steps on every Linux node before configuring `RUSTFS_VOLUMES`. +Bereiten Sie jeden RustFS-Speicherdatenträger als eigenständiges XFS-Dateisystem mit stabilem Label und stabilem Einhängepunkt vor. Führen Sie diese Schritte auf jedem Linux-Knoten aus, bevor Sie `RUSTFS_VOLUMES` konfigurieren. -:::warning[Formatting destroys data] +:::warning[Das Formatieren zerstört Daten] -The `mkfs.xfs` command erases the selected device. Confirm the device name, back up any required data, and ensure the disk is not used by the operating system before continuing. +Der Befehl `mkfs.xfs` löscht das ausgewählte Gerät. Bestätigen Sie den Gerätenamen, sichern Sie Daten, die Sie behalten müssen, und stellen Sie sicher, dass das Betriebssystem den Datenträger nicht verwendet, bevor Sie fortfahren. ::: -## 1. Identify the data disks +## 1. Die Speicherdatenträger identifizieren -List block devices, file systems, labels, and current mount points: +Listen Sie Blockgeräte, Dateisysteme, Labels und aktuelle Einhängepunkte auf: ```bash sudo lsblk -o NAME,SIZE,TYPE,FSTYPE,LABEL,UUID,MOUNTPOINTS ``` -Choose only dedicated data disks. Do not format the operating-system disk or a device that contains data you need to retain. +Wählen Sie nur dedizierte Speicherdatenträger. Formatieren Sie weder den Datenträger des Betriebssystems noch ein Gerät, das Daten enthält, die Sie behalten müssen. -## 2. Format a disk with XFS +## 2. Einen Datenträger mit XFS formatieren -The following example prepares `/dev/sdb` and assigns the label `RUSTFS0`. Replace the device name for your environment and use a unique label for each disk. +Das folgende Beispiel bereitet `/dev/sdb` vor und weist das Label `RUSTFS0` zu. Ersetzen Sie den Gerätenamen passend zu Ihrer Umgebung und verwenden Sie für jeden Datenträger ein eindeutiges Label. ```bash sudo mkfs.xfs -f -i size=512 -n ftype=1 -L RUSTFS0 /dev/sdb ``` -Repeat the command for additional disks with labels such as `RUSTFS1`, `RUSTFS2`, and `RUSTFS3`. +Wiederholen Sie den Befehl für weitere Datenträger mit Labels wie `RUSTFS1`, `RUSTFS2` und `RUSTFS3`. -## 3. Create a persistent mount +## 3. Einen dauerhaften Einhängepunkt anlegen -Create the mount point: +Legen Sie den Einhängepunkt an: ```bash sudo mkdir -p /data/rustfs0 ``` -Add an entry to `/etc/fstab` so the disk is mounted by its stable file-system label after a restart: +Fügen Sie einen Eintrag in `/etc/fstab` hinzu, damit der Datenträger nach einem Neustart über sein stabiles Dateisystem-Label eingehängt wird: ```ini title="/etc/fstab" LABEL=RUSTFS0 /data/rustfs0 xfs defaults,noatime,nodiratime 0 0 ``` -For more reliable device selection, we recommend mounting by file-system UUID. A UUID uniquely identifies the file system and avoids mounting the wrong disk if labels are duplicated or Linux device names change. Retrieve the UUID after formatting: +Wir empfehlen für eine zuverlässigere Geräteauswahl, über die UUID des Dateisystems einzuhängen. Eine UUID identifiziert das Dateisystem eindeutig und verhindert, dass der falsche Datenträger eingehängt wird, wenn Labels doppelt vorkommen oder sich die Linux-Gerätenamen ändern. Rufen Sie die UUID nach dem Formatieren ab: ```bash sudo blkid -s UUID -o value /dev/sdb ``` -Replace `` with the returned value, and use this entry instead of the `LABEL` entry above: +Ersetzen Sie `` durch den zurückgegebenen Wert und verwenden Sie diesen Eintrag anstelle des `LABEL`-Eintrags oben: ```ini title="/etc/fstab" UUID= /data/rustfs0 xfs defaults,noatime,nodiratime 0 0 ``` -Mount all entries and confirm the result: +Hängen Sie alle Einträge ein und bestätigen Sie das Ergebnis: ```bash sudo mount -a findmnt /data/rustfs0 ``` -For multiple disks, create one mount point and one `/etc/fstab` entry per file-system UUID. +Legen Sie bei mehreren Datenträgern für jede Dateisystem-UUID einen Einhängepunkt und einen Eintrag in `/etc/fstab` an. -## 4. Verify the prepared disks +## 4. Die vorbereiteten Datenträger prüfen -Confirm that every expected mount uses XFS and has sufficient free space: +Bestätigen Sie, dass jeder erwartete Einhängepunkt XFS verwendet und ausreichend freien Speicherplatz bietet: ```bash df -hT /data/rustfs0 sudo xfs_info /data/rustfs0 ``` -Use the verified mount paths when you configure `RUSTFS_VOLUMES`. Keep disk labels and mount paths consistent across nodes in a distributed deployment. +Verwenden Sie die geprüften Einhängepfade, wenn Sie `RUSTFS_VOLUMES` konfigurieren. Halten Sie Labels und Einhängepfade der Datenträger in einer verteilten Bereitstellung auf allen Knoten einheitlich. -## Next steps +## Nächste Schritte -- [Choose a deployment topology](/installation#deployment-mode-comparison) -- [Continue with Linux prerequisites and service setup](/installation/linux/prerequisites-and-service) \ No newline at end of file +- [Bereitstellungstopologie auswählen](/de/installation#deployment-mode-comparison) +- [Mit Linux-Voraussetzungen und Diensteinrichtung fortfahren](/de/installation/linux/prerequisites-and-service) diff --git a/content/de/installation/requirement/ec-configuration.md b/content/de/installation/requirement/ec-configuration.md index e38e4f7ea..7b7860e16 100644 --- a/content/de/installation/requirement/ec-configuration.md +++ b/content/de/installation/requirement/ec-configuration.md @@ -1,32 +1,32 @@ --- -title: "EC Configuration" -description: "Plan and configure RustFS erasure-set size and parity before deploying storage pools." +title: "EC-Konfiguration" +description: "Diese Seite beschreibt, wie Sie die Größe des Erasure-Sets und die Parität von RustFS planen und konfigurieren, bevor Sie Speicherpools bereitstellen." --- -RustFS uses Reed-Solomon erasure coding (EC) to distribute each object across the drives in an erasure set. Use this page to estimate usable capacity, understand the automatic defaults, and decide whether your deployment needs an explicit parity setting. +RustFS verwendet Reed-Solomon-Erasure-Coding (EC), um jedes Objekt auf die Datenträger eines Erasure-Sets zu verteilen. Schätzen Sie auf dieser Seite die nutzbare Kapazität, verstehen Sie die automatischen Standardwerte und entscheiden Sie, ob Ihre Bereitstellung eine ausdrückliche Paritätseinstellung benötigt. -## Understand the layout +## Den Aufbau verstehen -Each storage pool is divided into one or more erasure sets. For a set with `N` drives and `M` parity shards: +Jeder Speicherpool ist in ein oder mehrere Erasure-Sets unterteilt. Für ein Set mit `N` Datenträgern und `M` Paritätsshards gilt: -- data shards: `N - M` -- parity shards: `M` -- maximum unavailable shards that can be reconstructed: `M` -- approximate capacity efficiency: `(N - M) / N` +- Datenshards: `N - M` +- Paritätsshards: `M` +- maximale Anzahl nicht verfügbarer Shards, die rekonstruiert werden können: `M` +- ungefähre Kapazitätseffizienz: `(N - M) / N` -For example, a 16-drive set with `EC:4` stores 12 data shards and 4 parity shards. Its approximate capacity efficiency is 75% before file-system, metadata, and operational overhead. +Ein Set mit 16 Datenträgern und `EC:4` speichert beispielsweise 12 Datenshards und 4 Paritätsshards. Die ungefähre Kapazitätseffizienz beträgt 75 %, bevor der Aufwand für Dateisystem, Metadaten und Betrieb hinzukommt. -:::note[Failure domains] +:::note[Ausfalldomänen] -Parity describes unavailable shards within one erasure set. Node-level fault tolerance depends on how the set's drives are distributed across nodes. Do not assume that `EC:4` always tolerates four complete node failures; a node can host multiple drives from the same set. +Die Parität beschreibt nicht verfügbare Shards innerhalb eines Erasure-Sets. Die Fehlertoleranz auf Knotenebene hängt davon ab, wie die Datenträger des Sets auf die Knoten verteilt sind. Gehen Sie nicht davon aus, dass `EC:4` immer vier vollständige Knotenausfälle toleriert; ein Knoten kann mehrere Datenträger desselben Sets aufnehmen. ::: -## Automatic parity +## Automatische Parität -We recommend leaving `RUSTFS_STORAGE_CLASS_STANDARD` unset unless you have a specific, validated durability or capacity requirement. RustFS derives STANDARD parity independently for each pool from its drives per erasure set: +Wir empfehlen, `RUSTFS_STORAGE_CLASS_STANDARD` nicht zu setzen, sofern Sie keine konkrete, geprüfte Anforderung an Haltbarkeit oder Kapazität haben. RustFS leitet die STANDARD-Parität für jeden Pool unabhängig aus der Anzahl der Datenträger pro Erasure-Set ab: -| Drives per erasure set (`N`) | Automatic STANDARD parity | Data shards | Approximate efficiency | +| Datenträger pro Erasure-Set (`N`) | Automatische STANDARD-Parität | Datenshards | Ungefähre Effizienz | | --- | --- | --- | --- | | 1 | `EC:0` | 1 | 100% | | 2–3 | `EC:1` | `N - 1` | 50%–67% | @@ -34,82 +34,82 @@ We recommend leaving `RUSTFS_STORAGE_CLASS_STANDARD` unset unless you have a spe | 6–7 | `EC:3` | `N - 3` | 50%–57% | | 8–16 | `EC:4` | `N - 4` | 50%–75% | -Multi-drive erasure sets contain between 2 and 16 drives. A single-drive deployment is a separate layout with zero parity. +Erasure-Sets mit mehreren Datenträgern umfassen 2 bis 16 Datenträger. Eine Bereitstellung mit einem einzelnen Datenträger ist eine eigene Anordnung ohne Parität. -:::warning[Use the set width, not the cluster total] +:::warning[Die Set-Breite verwenden, nicht die Summe des Clusters] -Validate parity against the number of drives in each erasure set, not the total number of drives in the cluster. A cluster can contain multiple sets or pools with different widths. +Prüfen Sie die Parität anhand der Anzahl der Datenträger in jedem Erasure-Set, nicht anhand der Gesamtzahl der Datenträger im Cluster. Ein Cluster kann mehrere Erasure-Sets oder Speicherpools mit unterschiedlicher Breite enthalten. ::: -## Estimate usable capacity +## Nutzbare Kapazität schätzen -For a pool whose sets all use the same width and parity, estimate EC capacity with: +Schätzen Sie die EC-Kapazität für einen Pool, dessen Sets alle dieselbe Breite und dieselbe Parität verwenden, mit: $$ -\text{usable capacity} \approx \text{raw capacity} \times \frac{N-M}{N} +\text{nutzbare Kapazität} \approx \text{Rohkapazität} \times \frac{N-M}{N} $$ -For example, 16 equal 10 TiB drives arranged as one 16-drive set with `EC:4` provide approximately: +16 gleiche Datenträger mit je 10 TiB, angeordnet als ein Set mit 16 Datenträgern und `EC:4`, ergeben beispielsweise ungefähr: $$ 160\ \text{TiB} \times \frac{16-4}{16} = 120\ \text{TiB} $$ -Reserve additional capacity for XFS, object metadata, versioning, incomplete uploads, healing, and normal operational headroom. Treat the result as a planning estimate, not guaranteed available space. +Reservieren Sie zusätzliche Kapazität für XFS, Objektmetadaten, Versionierung, unvollständige Uploads, Datenwiederherstellung (Healing) und den normalen betrieblichen Spielraum. Behandeln Sie das Ergebnis als Planungsschätzung, nicht als garantiert verfügbaren Speicherplatz. -## Configure parity +## Parität konfigurieren -Set EC variables in the same environment file used by the RustFS service, such as `/etc/default/rustfs`. +Setzen Sie die EC-Variablen in derselben Umgebungsdatei, die der RustFS-Dienst verwendet, zum Beispiel in `/etc/default/rustfs`. -To use the recommended automatic STANDARD parity, omit `RUSTFS_STORAGE_CLASS_STANDARD` or leave it empty: +Lassen Sie `RUSTFS_STORAGE_CLASS_STANDARD` weg oder leer, um die empfohlene automatische STANDARD-Parität zu verwenden: ```ini title="/etc/default/rustfs" RUSTFS_STORAGE_CLASS_STANDARD= ``` -To pin parity explicitly, use the `EC:` format: +Um die Parität ausdrücklich festzulegen, verwenden Sie das Format `EC:`: ```ini title="/etc/default/rustfs" RUSTFS_STORAGE_CLASS_STANDARD=EC:4 RUSTFS_STORAGE_CLASS_RRS=EC:1 ``` -`RUSTFS_STORAGE_CLASS_STANDARD` controls writes using the `STANDARD` storage class. `RUSTFS_STORAGE_CLASS_RRS` controls `REDUCED_REDUNDANCY` writes and defaults to one parity shard on multi-drive sets. RustFS accepts these two storage classes for local writes. +`RUSTFS_STORAGE_CLASS_STANDARD` steuert Schreibvorgänge mit der Speicherklasse `STANDARD`. `RUSTFS_STORAGE_CLASS_RRS` steuert Schreibvorgänge mit `REDUCED_REDUNDANCY` und verwendet auf Sets mit mehreren Datenträgern standardmäßig einen Paritätsshard. RustFS akzeptiert diese beiden Speicherklassen für lokale Schreibvorgänge. -Explicit settings must satisfy all of these rules: +Ausdrückliche Einstellungen müssen alle folgenden Regeln erfüllen: -- parity must be no greater than half of the drives in every target set: `M <= N / 2` -- STANDARD parity must be greater than or equal to REDUCED_REDUNDANCY parity when both are non-zero -- the configured parity must be valid for every pool, including the narrowest pool +- Die Parität darf in jedem Ziel-Set höchstens die Hälfte der Datenträger betragen: `M <= N / 2` +- Die STANDARD-Parität muss größer oder gleich der Parität von `REDUCED_REDUNDANCY` sein, wenn beide ungleich null sind +- Die konfigurierte Parität muss für jeden Pool gültig sein, einschließlich des schmalsten Pools -RustFS validates explicit storage classes against each pool during startup. An invalid value causes startup to fail instead of silently reducing parity. Remove the explicit STANDARD value to return to per-pool automatic parity, or choose a value every pool can satisfy. +RustFS prüft ausdrückliche Speicherklassen beim Start gegen jeden Pool. Ein ungültiger Wert lässt den Start fehlschlagen, statt die Parität stillschweigend zu senken. Entfernen Sie den ausdrücklichen STANDARD-Wert, um zur automatischen Parität je Pool zurückzukehren, oder wählen Sie einen Wert, den jeder Pool erfüllen kann. -## Control erasure-set width +## Breite des Erasure-Sets steuern -RustFS normally selects a valid set width automatically from the volume topology. Multi-drive set widths range from 2 through 16. +RustFS wählt eine gültige Set-Breite normalerweise automatisch aus der Volume-Topologie. Die Breite von Sets mit mehreren Datenträgern reicht von 2 bis 16. -`RUSTFS_ERASURE_SET_DRIVE_COUNT` can pin the width when you need a specific symmetric layout: +Mit `RUSTFS_ERASURE_SET_DRIVE_COUNT` können Sie die Breite festlegen, wenn Sie eine bestimmte symmetrische Anordnung benötigen: ```ini title="/etc/default/rustfs" RUSTFS_ERASURE_SET_DRIVE_COUNT=16 ``` -The value must divide the pool topology symmetrically and be valid for every volume expansion pattern. RustFS rejects a width that cannot evenly partition the configured endpoints. Leave this variable unset unless you have verified the complete pool layout. +Der Wert muss die Pool-Topologie symmetrisch teilen und für jedes Muster zur Erweiterung der Volumes gültig sein. RustFS lehnt eine Breite ab, die die konfigurierten Endpunkte nicht gleichmäßig aufteilen kann. Setzen Sie diese Variable nicht, sofern Sie die vollständige Anordnung des Pools nicht geprüft haben. -## Validate the configuration +## Konfiguration prüfen -Before starting or restarting RustFS: +Bevor Sie RustFS starten oder neu starten: -1. Determine the drives per erasure set for every pool. -2. Confirm that explicit parity does not exceed half of the narrowest set width. -3. Estimate usable capacity and reserve operational headroom. -4. Keep the same service environment configuration on every node. +1. Ermitteln Sie für jeden Pool die Anzahl der Datenträger pro Erasure-Set. +2. Bestätigen Sie, dass die ausdrückliche Parität nicht die Hälfte der schmalsten Set-Breite überschreitet. +3. Schätzen Sie die nutzbare Kapazität und reservieren Sie betrieblichen Spielraum. +4. Behalten Sie auf jedem Knoten dieselbe Umgebungskonfiguration des Dienstes bei. -After startup, use the Console **Status** page or `rc admin info cluster` to confirm the backend layout, erasure-coding parity, drive availability, and pool membership. See [Status Check](/operations/status-check) for the complete workflow. +Verwenden Sie nach dem Start die Seite **Status** der Console (Weboberfläche) oder `rc admin info cluster`, um den Aufbau des Backends, die Erasure-Coding-Parität, die Verfügbarkeit der Datenträger und die Pool-Zugehörigkeit zu bestätigen. Den vollständigen Ablauf beschreibt [Statusprüfung](/de/operations/status-check). -## Next steps +## Nächste Schritte -- [Prepare data disks](./disk-preparation.md) -- [Choose a deployment topology](/installation#deployment-mode-comparison) -- [Review all storage environment variables](/reference/environment-variables#storage--erasure) \ No newline at end of file +- [Speicherdatenträger vorbereiten](./disk-preparation.md) +- [Bereitstellungstopologie auswählen](/de/installation#deployment-mode-comparison) +- [Alle Umgebungsvariablen für den Speicher prüfen](/de/reference/environment-variables#storage--erasure) diff --git a/content/de/installation/windows/index.md b/content/de/installation/windows/index.md index 1f98293b3..ce4d3975f 100644 --- a/content/de/installation/windows/index.md +++ b/content/de/installation/windows/index.md @@ -1,125 +1,125 @@ --- -title: "Install RustFS on Windows" -description: "Install a local RustFS instance on Windows with RustFS Launcher or the standalone server binary." +title: "RustFS unter Windows installieren" +description: "Installieren Sie eine lokale RustFS-Instanz unter Windows mit RustFS Launcher oder der eigenständigen Server-Binary." --- -This guide provides two ways to run **RustFS** on Windows: use the graphical **RustFS Launcher**, or download and run the standalone server binary from PowerShell. Both methods create a local, single-node instance suitable for evaluation, development, and testing. +Diese Anleitung zeigt zwei Wege, **RustFS** auf Windows zu betreiben: über die grafische Anwendung **RustFS Launcher** oder indem Sie die eigenständige Server-Binary herunterladen und in PowerShell ausführen. Beide Wege erzeugen eine lokale Einzelknoten-Instanz für Evaluierung, Entwicklung und Tests. -:::warning[Nur für Entwicklung und Debugging] +:::warning[Nur für Entwicklung und Fehlersuche] -Die Windows-Version von RustFS ist ausschließlich für Entwicklung und Debugging vorgesehen und wird **nicht für Produktionsumgebungen empfohlen**. Für Produktionsumgebungen empfehlen wir [Linux](/de/installation/linux). +Die Windows-Version von RustFS ist ausschließlich für Entwicklung und Fehlersuche vorgesehen und wird **für produktive Bereitstellungen nicht empfohlen**. Für produktive Arbeitslasten empfehlen wir [Linux](/de/installation/linux). -These procedures run RustFS as a desktop process, not as a Windows service. For a production or distributed deployment, use the [Linux installation guides](/installation/linux). +Diese Verfahren führen RustFS als Desktop-Prozess aus, nicht als Windows-Dienst. Für eine produktive oder verteilte Bereitstellung verwenden Sie die [Linux-Installationsanleitungen](/de/installation/linux). ::: -## 1. Check the prerequisites +## 1. Voraussetzungen prüfen -Before you begin, make sure that: +Stellen Sie vor dem Start Folgendes sicher: -- You are using 64-bit Windows on an x86-64 processor. Launcher currently bundles the Windows x86-64 RustFS binary. -- You have permission to install or run applications and to write to the selected data directory. -- TCP ports `9000` and `9001` are available, or you have selected two other unused ports. -- You have created a dedicated data directory, such as `D:\rustfs\data`. +- Sie verwenden 64-Bit-Windows auf einem x86-64-Prozessor. Launcher bündelt derzeit die Windows-x86-64-Binary von RustFS. +- Sie dürfen Anwendungen installieren oder ausführen und in das gewählte Datenverzeichnis schreiben. +- Die TCP-Ports `9000` und `9001` sind frei, oder Sie haben zwei andere ungenutzte Ports gewählt. +- Sie haben ein eigenes Datenverzeichnis angelegt, zum Beispiel `D:\rustfs\data`. -:::warning[Protect the data directory] +:::warning[Datenverzeichnis schützen] -Use an empty directory on a disk with enough free space. Do not store unrelated files in this directory, and do not edit RustFS data files while the server is running. +Verwenden Sie ein leeres Verzeichnis auf einem Datenträger mit ausreichend freiem Speicher. Legen Sie dort keine fremden Dateien ab und bearbeiten Sie RustFS-Datendateien nicht, während der Server läuft. ::: -## 2. Choose an installation method +## 2. Installationsmethode wählen -| Method | Use it when | Management model | +| Methode | Geeignet, wenn | Verwaltungsmodell | | --- | --- | --- | -| RustFS Launcher | You want a graphical setup and built-in log viewer. | Launcher starts and stops the bundled RustFS process. | -| Standalone binary | You want explicit PowerShell commands or scripting. | The PowerShell session owns the RustFS process. | +| RustFS Launcher | Sie eine grafische Einrichtung und eine integrierte Protokollanzeige möchten. | Launcher startet und stoppt den mitgelieferten RustFS-Prozess. | +| Eigenständige Binary | Sie explizite PowerShell-Befehle oder Skripte möchten. | Der RustFS-Prozess läuft in der PowerShell-Sitzung. | -## Install with RustFS Launcher +## Mit RustFS Launcher installieren -### 3. Download and install Launcher +### 3. Launcher herunterladen und installieren -1. Open the [RustFS Launcher Releases page](https://github.com/rustfs/launcher/releases). -2. Select the latest release and download its Windows x86-64 installer from **Assets**. Do not download **Source code**, which is for building Launcher from source. -3. Double-click the installer and follow the prompts. -4. Open **RustFS Launcher** from the Start menu if it does not open automatically. +1. Öffnen Sie die [Release-Seite von RustFS Launcher](https://github.com/rustfs/launcher/releases). +2. Wählen Sie das neueste Release und laden Sie das Windows-x86-64-Installationsprogramm aus **Assets** herunter. Laden Sie **Source code** nicht herunter. Es dient dazu, Launcher aus dem Quellcode zu bauen. +3. Doppelklicken Sie auf das Installationsprogramm und folgen Sie den Eingabeaufforderungen. +4. Öffnen Sie **RustFS Launcher** aus dem Startmenü, falls die Anwendung nicht automatisch startet. -If Microsoft Defender SmartScreen displays a warning, verify that the installer came from the official `rustfs/launcher` Releases page before allowing it to run. Do not disable Windows security features globally. +Wenn Microsoft Defender SmartScreen eine Warnung anzeigt, prüfen Sie, dass das Installationsprogramm von der offiziellen Release-Seite `rustfs/launcher` stammt, bevor Sie die Ausführung zulassen. Deaktivieren Sie Windows-Sicherheitsfunktionen nicht global. -### 4. Configure Launcher +### 4. Launcher konfigurieren -Configure the fields in the Launcher window: +Konfigurieren Sie die Felder im Launcher-Fenster: -| Section | Field | Recommended value | Description | +| Bereich | Feld | Empfohlener Wert | Beschreibung | | --- | --- | --- | --- | -| Dataset Mount | Data Path | `D:\rustfs\data` | Existing directory where RustFS stores object data. | -| Ports & Access | API Port | `9000` | S3-compatible API port. | -| Ports & Access | Host | `127.0.0.1` | Restricts access to this computer. | -| Ports & Access | Console Endpoint | Enabled | Enables the web Console; Launcher disables it by default. | -| Ports & Access | Console Port | `9001` | Console port, which must differ from the API port. | -| Credentials | Access Key | `` | Administrator access key for this instance. | -| Credentials | Secret Key | `` | Administrator secret key for this instance. | +| Dataset Mount | Data Path | `D:\rustfs\data` | Vorhandenes Verzeichnis, in dem RustFS Objektdaten speichert. | +| Ports & Access | API Port | `9000` | Port der S3-kompatiblen API. | +| Ports & Access | Host | `127.0.0.1` | Beschränkt den Zugriff auf diesen Computer. | +| Ports & Access | Console Endpoint | Enabled | Aktiviert die Console (Weboberfläche). Launcher deaktiviert sie standardmäßig. | +| Ports & Access | Console Port | `9001` | Console-Port. Er muss sich vom API-Port unterscheiden. | +| Credentials | Access Key | `` | Administrator-Zugriffsschlüssel für diese Instanz. | +| Credentials | Secret Key | `` | Geheimer Administrator-Zugriffsschlüssel für diese Instanz. | -Select the data directory with **Browse** or drag it into Launcher. Launcher requires the directory to exist before startup. +Wählen Sie das Datenverzeichnis mit **Browse** oder ziehen Sie es in Launcher. Launcher setzt voraus, dass das Verzeichnis vor dem Start existiert. -Replace the credential placeholders with your own values. Launcher initially displays default local-test credentials; do not retain them on a computer accessible by other users. +Ersetzen Sie die Platzhalter für die Zugangsdaten durch eigene Werte. Launcher zeigt anfangs die standardmäßigen lokalen Test-Zugangsdaten an. Behalten Sie sie nicht auf einem Computer bei, auf den andere Benutzer zugreifen können. -:::warning[Network exposure] +:::warning[Netzwerkexposition] -Keep **Host** set to `127.0.0.1` unless another computer must connect to RustFS. A non-loopback address exposes the API and Console on the corresponding network interfaces. Configure Windows Defender Firewall and strong credentials before allowing remote access. +Lassen Sie **Host** auf `127.0.0.1`, sofern nicht ein anderer Computer eine Verbindung zu RustFS herstellen muss. Jede Adresse außer `127.0.0.1` legt die API und die Console auf den zugehörigen Netzwerkschnittstellen offen. Konfigurieren Sie die Windows Defender Firewall und starke Zugangsdaten, bevor Sie Fernzugriff zulassen. ::: -### 5. Start and verify RustFS +### 5. RustFS starten und prüfen -1. Select **Launch RustFS**. -2. Wait for Launcher to report that the configured endpoint is online. -3. Open `http://localhost:9001` and sign in with the access key and secret key that you configured. -4. Use `http://localhost:9000` as the endpoint for S3-compatible clients. +1. Wählen Sie **Launch RustFS**. +2. Warten Sie, bis Launcher meldet, dass der konfigurierte Endpunkt online ist. +3. Öffnen Sie `http://localhost:9001` und melden Sie sich mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel an, die Sie konfiguriert haben. +4. Verwenden Sie `http://localhost:9000` als Endpunkt für S3-kompatible Clients. -![RustFS Launcher showing the service online with API port 9000, Console port 9001, and successful startup logs](./images/windows-rustfs-launcher.jpg) +![RustFS Launcher mit online gemeldetem Dienst, API-Port 9000, Console-Port 9001 und erfolgreichen Startprotokollen](./images/windows-rustfs-launcher.jpg) -If you changed the host or ports, use those values instead. The Console URL is available only when **Console Endpoint** is enabled. +Wenn Sie Host oder Ports geändert haben, verwenden Sie diese Werte. Die Console-URL ist nur verfügbar, wenn **Console Endpoint** aktiviert ist. -Launcher locks its configuration while it manages a running process. It also creates a `logs` directory next to the data directory. For example, a data path of `D:\rustfs\data` places server log files under `D:\rustfs\logs`. +Launcher sperrt seine Konfiguration, solange er einen laufenden Prozess verwaltet. Er legt außerdem ein Verzeichnis `logs` neben dem Datenverzeichnis an. Bei einem Datenpfad `D:\rustfs\data` liegen die Server-Protokolldateien beispielsweise unter `D:\rustfs\logs`. -### 6. Stop or exit Launcher +### 6. Launcher anhalten oder beenden -Select **Stop RustFS** before changing configuration, disconnecting the data disk, or shutting down Windows. +Wählen Sie **Stop RustFS**, bevor Sie die Konfiguration ändern, den Datenträger trennen oder Windows herunterfahren. -Closing the Launcher window hides it in the Windows system tray; it does not stop RustFS. To stop the managed process and exit Launcher, right-click the tray icon and select **Quit**. Select **Show**, or left-click the tray icon, to restore the window. +Wenn Sie das Launcher-Fenster schließen, wird es im Infobereich von Windows ausgeblendet. RustFS wird dadurch nicht angehalten. Um den verwalteten Prozess anzuhalten und Launcher zu beenden, klicken Sie mit der rechten Maustaste auf das Symbol im Infobereich und wählen Sie **Quit**. Wählen Sie **Show** oder klicken Sie mit der linken Maustaste auf das Symbol, um das Fenster wiederherzustellen. -## Install the standalone binary +## Eigenständige Binary installieren -### 7. Download and extract the binary +### 7. Binary herunterladen und entpacken -1. Open the [RustFS Releases page](https://github.com/rustfs/rustfs/releases). -2. Select the required release and download the Windows x86-64 ZIP archive from **Assets**. The asset name begins with `rustfs-windows-x86_64`. -3. Open PowerShell and create directories for the program and its data: +1. Öffnen Sie die [RustFS-Release-Seite](https://github.com/rustfs/rustfs/releases). +2. Wählen Sie das benötigte Release und laden Sie das Windows-x86-64-ZIP-Archiv aus **Assets** herunter. Der Asset-Name beginnt mit `rustfs-windows-x86_64`. +3. Öffnen Sie PowerShell und legen Sie Verzeichnisse für das Programm und seine Daten an: ```powershell New-Item -ItemType Directory -Force -Path C:\rustfs\bin New-Item -ItemType Directory -Force -Path D:\rustfs\data ``` -4. Extract the downloaded archive. Replace `` with the version in the downloaded filename: +4. Entpacken Sie das heruntergeladene Archiv. Ersetzen Sie `` durch die Version im heruntergeladenen Dateinamen: ```powershell Expand-Archive -Path "$HOME\Downloads\rustfs-windows-x86_64-.zip" -DestinationPath C:\rustfs\bin -Force ``` -5. Confirm that the extracted binary runs: +5. Prüfen Sie, dass die entpackte Binary startet: ```powershell Set-Location C:\rustfs\bin .\rustfs.exe --help ``` -If the archive extracts `rustfs.exe` into a nested directory, change to that directory or move the executable into `C:\rustfs\bin` before continuing. +Wenn das Archiv `rustfs.exe` in ein verschachteltes Verzeichnis entpackt, wechseln Sie in dieses Verzeichnis oder verschieben Sie die ausführbare Datei nach `C:\rustfs\bin`, bevor Sie fortfahren. -### 8. Start the standalone server +### 8. Eigenständigen Server starten -Set credentials only for the current PowerShell session, then start RustFS with explicit addresses: +Setzen Sie die Zugangsdaten nur für die aktuelle PowerShell-Sitzung und starten Sie RustFS anschließend mit expliziten Adressen: ```powershell $env:RUSTFS_ACCESS_KEY = "" @@ -133,61 +133,61 @@ Set-Location C:\rustfs\bin "D:\rustfs\data" ``` -Keep the PowerShell window open while RustFS is running. Press `Ctrl+C` in that window to stop the server. +Lassen Sie das PowerShell-Fenster geöffnet, solange RustFS läuft. Drücken Sie in diesem Fenster `Ctrl+C`, um den Server anzuhalten. -:::tip[Credential handling] +:::tip[Umgang mit Zugangsdaten] -Session environment variables avoid placing credentials directly in the command line. For repeated or automated use, prefer the `RUSTFS_ACCESS_KEY_FILE` and `RUSTFS_SECRET_KEY_FILE` environment variables and protect those files with Windows access controls. +Sitzungs-Umgebungsvariablen vermeiden es, Zugangsdaten direkt in die Befehlszeile zu schreiben. Bevorzugen Sie für wiederholte oder automatisierte Nutzung die Umgebungsvariablen `RUSTFS_ACCESS_KEY_FILE` und `RUSTFS_SECRET_KEY_FILE` und schützen Sie diese Dateien mit den Windows-Zugriffssteuerungen. ::: -### 9. Verify the standalone server +### 9. Eigenständigen Server prüfen -Open `http://localhost:9001` and sign in with the configured credentials. Use `http://localhost:9000` as the endpoint for S3-compatible clients. RustFS defaults to path-style addressing, so configure clients accordingly. +Öffnen Sie `http://localhost:9001` und melden Sie sich mit den konfigurierten Zugangsdaten an. Verwenden Sie `http://localhost:9000` als Endpunkt für S3-kompatible Clients. RustFS verwendet standardmäßig pfadbasierte Adressierung (Path-Style). Konfigurieren Sie die Clients entsprechend. -To perform an end-to-end check, create a bucket named `my-bucket`, upload `hello.txt`, and confirm that the object appears in the bucket. +Prüfen Sie den Ablauf durchgehend: Legen Sie einen Bucket namens `my-bucket` an, laden Sie `hello.txt` hoch und prüfen Sie, dass das Objekt im Bucket erscheint. -## Confirm a successful installation +## Erfolgreiche Installation bestätigen -Whether you used Launcher or the standalone binary, a successful Console sign-in opens the **Buckets** page. From here, you can create `my-bucket` and begin storing objects. +Nach der Anmeldung an der Console öffnet sich die Seite **Buckets**, unabhängig davon, ob Sie Launcher oder die eigenständige Binary verwendet haben. Von hier aus können Sie `my-bucket` anlegen und Objekte speichern. -![RustFS Console Buckets page after a successful sign-in](./images/rustfs-console-login.png) +![Seite Buckets der RustFS Console nach erfolgreicher Anmeldung](./images/rustfs-console-login.png) -## Troubleshooting +## Fehlerbehebung -### Windows blocks the installer or executable +### Windows blockiert das Installationsprogramm oder die ausführbare Datei -Confirm that the file came from the official RustFS GitHub organization. Inspect the file's **Properties** dialog and, when Windows provides the option, select **Unblock** only after verifying the source. +Prüfen Sie, dass die Datei aus der offiziellen GitHub-Organisation von RustFS stammt. Öffnen Sie den Dialog **Properties** (Eigenschaften) der Datei. Wenn Windows die Option anbietet, wählen Sie **Unblock** (Zulassen) erst, nachdem Sie die Quelle geprüft haben. -### The data path is rejected +### Der Datenpfad wird abgelehnt -Confirm that the directory exists and that your Windows account has read and write access. Launcher does not create the selected data directory for you. +Prüfen Sie, dass das Verzeichnis existiert und Ihr Windows-Konto Lese- und Schreibzugriff hat. Launcher legt das gewählte Datenverzeichnis nicht für Sie an. -### The API or Console port is unavailable +### Der API- oder Console-Port ist nicht verfügbar -The ports must be numbers from `1` to `65535`, must differ from each other, and must not already be in use. Inspect the default ports in PowerShell: +Die Ports müssen Zahlen von `1` bis `65535` sein, sich voneinander unterscheiden und dürfen nicht bereits belegt sein. Prüfen Sie die Standardports in PowerShell: ```powershell Get-NetTCPConnection -LocalPort 9000,9001 -ErrorAction SilentlyContinue ``` -Stop the conflicting application or select unused ports, then start RustFS again. +Beenden Sie die kollidierende Anwendung oder wählen Sie freie Ports und starten Sie RustFS erneut. -### The Console does not open +### Die Console öffnet sich nicht -For Launcher, confirm that **Console Endpoint** is enabled. For the standalone binary, confirm that the process is still running and that `--console-enable true` is present. The current Console default is port `9001`; port `7001` is not used by the current Launcher configuration. +Prüfen Sie bei Launcher, dass **Console Endpoint** aktiviert ist. Prüfen Sie bei der eigenständigen Binary, dass der Prozess noch läuft und `--console-enable true` gesetzt ist. Der aktuelle Console-Standard ist Port `9001`. Die aktuelle Launcher-Konfiguration verwendet Port `7001` nicht. -### Launcher reports an external RustFS process +### Launcher meldet einen externen RustFS-Prozess -Another process is listening on the configured API address, but Launcher did not start it. Stop that process or choose another API port. Launcher cannot stop a process it does not manage. +Ein anderer Prozess lauscht auf der konfigurierten API-Adresse, aber Launcher hat ihn nicht gestartet. Beenden Sie diesen Prozess oder wählen Sie einen anderen API-Port. Launcher kann einen Prozess nicht anhalten, den er nicht verwaltet. -### RustFS exits after launch +### RustFS beendet sich nach dem Start -In Launcher, inspect both the application and RustFS tabs in the built-in log viewer. For a standalone installation, inspect the PowerShell output. Common causes include a missing data directory, insufficient permissions, or a port conflict. +Prüfen Sie in Launcher beide Registerkarten, die der Anwendung und die von RustFS, in der integrierten Protokollanzeige. Prüfen Sie bei einer eigenständigen Installation die PowerShell-Ausgabe. Häufige Ursachen sind ein fehlendes Datenverzeichnis, unzureichende Berechtigungen oder ein Portkonflikt. -## Next steps +## Nächste Schritte -- Review the [S3 API guide](/administration/protocols/s3) before connecting a client. -- Learn how to [create a bucket](/administration/data/bucket/creation). -- See [status checks](/operations/status-check) for additional verification methods. -- Use the [Linux installation guides](/installation/linux) for a production-oriented deployment. +- Lesen Sie die [S3-API-Anleitung](/de/administration/protocols/s3), bevor Sie einen Client verbinden. +- Erfahren Sie, wie Sie [einen Bucket anlegen](/de/administration/data/bucket/creation). +- Weitere Prüfmöglichkeiten finden Sie unter [Statusprüfungen](/de/operations/status-check). +- Verwenden Sie die [Linux-Installationsanleitungen](/de/installation/linux) für eine auf den Produktivbetrieb ausgerichtete Bereitstellung. diff --git a/content/de/integration/tls-configured.md b/content/de/integration/tls-configured.md index 862913e1d..75a25e89b 100644 --- a/content/de/integration/tls-configured.md +++ b/content/de/integration/tls-configured.md @@ -1,22 +1,22 @@ --- -title: "TLS Configuration" -description: "Configure TLS for secure access." +title: "TLS-Konfiguration" +description: "Aktivieren Sie TLS für die S3-API und die Console von RustFS unter Linux und Docker." --- -Configure TLS for secure access. Set the `RUSTFS_TLS_PATH` environment variable. +Konfigurieren Sie TLS für den sicheren Zugriff. Setzen Sie die Umgebungsvariable `RUSTFS_TLS_PATH`. -## Configuration +## Konfiguration -### Prerequisites +### Voraussetzungen -- A running RustFS instance (see [Installation Guide](../installation/index.md)). -- Certificate pair (cert and key). +- Eine laufende RustFS-Instanz (siehe [Installationsanleitung](../installation/index.md)). +- Ein TLS-Zertifikat und der zugehörige private Schlüssel. -**Note**: Certificates must be named `rustfs_cert.pem` and `rustfs_key.pem` and placed in the specified path. +**Hinweis**: Die Zertifikate müssen `rustfs_cert.pem` und `rustfs_key.pem` heißen und im angegebenen Pfad liegen. ### Linux -1. Edit the RustFS instance configuration file (default `/etc/default/rustfs`) and add the `RUSTFS_TLS_PATH` environment variable. +1. Bearbeiten Sie die Konfigurationsdatei der RustFS-Instanz (standardmäßig `/etc/default/rustfs`) und fügen Sie die Umgebungsvariable `RUSTFS_TLS_PATH` hinzu. ```bash # Edit RustFS instance configuration file @@ -26,19 +26,19 @@ Configure TLS for secure access. Set the `RUSTFS_TLS_PATH` environment variable. RUSTFS_TLS_PATH="/opt/tls" ``` -**Note**: You can specify any path for `RUSTFS_TLS_PATH`, but it must contain both `rustfs_cert.pem` and `rustfs_key.pem`. +**Hinweis**: Sie können für `RUSTFS_TLS_PATH` einen beliebigen Pfad angeben. Er muss jedoch sowohl `rustfs_cert.pem` als auch `rustfs_key.pem` enthalten. -2. Restart the RustFS instance. +2. Starten Sie die RustFS-Instanz neu. ```bash systemctl restart rustfs ``` -TLS now applies to both listeners: the S3 API at `https://rustfs.example.com:9000` and the Console at `https://rustfs.example.com:9001`. +TLS gilt danach für beide Listener: die S3-API unter `https://rustfs.example.com:9000` und die Console unter `https://rustfs.example.com:9001`. ### Docker -1. Mount the certificate path via `-v` and specify `RUSTFS_TLS_PATH` via `-e`. +1. Hängen Sie den Zertifikatspfad mit `-v` ein und setzen Sie `RUSTFS_TLS_PATH` mit `-e`. ```bash docker pull rustfs/rustfs:latest @@ -52,6 +52,10 @@ TLS now applies to both listeners: the S3 API at `https://rustfs.example.com:900 rustfs/rustfs:latest ``` -2. Restart the RustFS instance container, then access the S3 API at `https://rustfs.example.com:9000` and the Console at `https://rustfs.example.com:9001`. +2. Starten Sie den Container der RustFS-Instanz neu und greifen Sie anschließend auf die S3-API unter `https://rustfs.example.com:9000` und die Console unter `https://rustfs.example.com:9001` zu. -**Note**: Since the RustFS instance container runs as `rustfs` user by default, you need to ensure that the certificate files (`rustfs_key.pem` and `rustfs_cert.pem`) belong to the `rustfs` user, otherwise the RustFS instance will fail to read the certificate files due to permission issues, causing TLS configuration to fail. +:::note[Zugehörigkeit der Zertifikatsdateien] + +Der RustFS-Container läuft standardmäßig als Benutzer `rustfs` (UID `10001`). Stellen Sie sicher, dass dieser Benutzer Eigentümer von `rustfs_key.pem` und `rustfs_cert.pem` ist. Andernfalls kann RustFS die Zertifikate nicht lesen und TLS startet nicht. + +::: diff --git a/content/de/integration/virtual.md b/content/de/integration/virtual.md index 02a9ac4d5..65344c16d 100644 --- a/content/de/integration/virtual.md +++ b/content/de/integration/virtual.md @@ -1,61 +1,64 @@ --- -title: "Virtual Host Style" -description: "RustFS S3 Virtual Host Style and Path Style configuration." +title: "Anfragen im Virtual-Hosted-Stil" +description: "Konfigurieren Sie die pfadbasierte Adressierung (Path-Style) und die Adressierung im Virtual-Hosted-Stil für S3-URLs in RustFS." --- -RustFS complies with S3 protocols. S3 supports two request modes: +RustFS unterstützt beide Adressierungsarten für S3-URLs: -1. Virtual Host Style -2. Path Style +1. Adressierung im Virtual-Hosted-Stil +2. Pfadbasierte Adressierung -The difference lies in the bucket name placement. +Die beiden Arten unterscheiden sich darin, wo der Bucket-Name in der URL steht. -## Path Style +## Pfadbasierte Adressierung -Path Style is the default. In Path Style, the bucket name follows the endpoint. +Die pfadbasierte Adressierung ist der Standard. In einer pfadbasierten URL folgt der Bucket-Name auf den Endpunkt. -Example (Bucket: `test`, Host: `rustfs.yourdomain.com`): +Beispiel (Bucket: `test`, Host: `rustfs.yourdomain.com`): ```text http://rustfs.yourdomain.com/test ``` -**Note**: No configuration is required for Path Style. +**Hinweis**: Für die pfadbasierte Adressierung ist keine Konfiguration erforderlich. -## Virtual Host Style +## Adressierung im Virtual-Hosted-Stil -In Virtual Host Style, the bucket name is part of the domain. +Bei der Adressierung im Virtual-Hosted-Stil ist der Bucket-Name Teil der Domain. -Example (Bucket: `test`, Host: `rustfs.yourdomain.com`): +Beispiel (Bucket: `test`, Host: `rustfs.yourdomain.com`): ```text http://test.rustfs.yourdomain.com/ ``` -### Configuration +### Konfiguration -1. **DNS**: Configure wildcard DNS resolution (e.g., `*.rustfs.yourdomain.com` -> Server IP). -2. **Configuration**: Modify the configuration file (Linux: `/etc/default/rustfs`, Docker/K8s: env vars). -3. **Set Domain**: Set `RUSTFS_SERVER_DOMAINS = "rustfs.yourdomain.com"`. -4. **Restart**: Restart the service (`systemctl restart rustfs`). +1. **DNS**: Legen Sie einen Wildcard-DNS-Eintrag an (zum Beispiel `*.rustfs.yourdomain.com` → IP-Adresse Ihres Servers). +2. **Konfiguration**: Ändern Sie die Konfigurationsdatei (Linux: `/etc/default/rustfs`, Docker/Kubernetes: Umgebungsvariablen). +3. **Domain setzen**: Setzen Sie `RUSTFS_SERVER_DOMAINS = "rustfs.yourdomain.com"`. +4. **Neustart**: Starten Sie den Dienst neu (`systemctl restart rustfs`). -### Port in Domain (Optional) +### Port in der Domain (optional) -Virtual-host routing applies to the S3 API listener (port 9000 by default); RustFS automatically matches `Host` headers that carry the S3 listener's own port. Only when clients reach RustFS through a **different** port (for example via a proxy) do you need to include that port in `RUSTFS_SERVER_DOMAINS`. +Das Routing im Virtual-Hosted-Stil gilt für den Listener der S3-API (standardmäßig Port 9000). RustFS erkennt `Host`-Header automatisch, die den eigenen Port dieses Listeners enthalten. Nur wenn Clients RustFS über einen **anderen** Port erreichen (zum Beispiel über einen Proxy), müssen Sie diesen Port in `RUSTFS_SERVER_DOMAINS` angeben. -Example (`rustfs.yourdomain.com:8000`): +Beispiel (`rustfs.yourdomain.com:8000`): ```ini RUSTFS_SERVER_DOMAINS = "rustfs.yourdomain.com:8000" ``` -This ensures that requests like: +Damit werden Anfragen wie diese korrekt weitergeleitet: ```text http://my-bucket.rustfs.yourdomain.com:8000/ ``` -can be correctly resolved in Virtual Host Style mode. +Die Weiterleitung verwendet die Adressierung im Virtual-Hosted-Stil. -> ⚠️ Note: The value of `RUSTFS_SERVER_DOMAINS` must exactly match the **Host header** (including the port, if present) used by the client request +:::warning[Host-Header angleichen] +Der Wert von `RUSTFS_SERVER_DOMAINS` muss exakt dem `Host`-Header entsprechen (einschließlich des Ports, falls vorhanden), den Clients senden. + +::: diff --git a/content/de/operations/cluster-lifecycle.md b/content/de/operations/cluster-lifecycle.md index 33a8535c6..29d9eec16 100644 --- a/content/de/operations/cluster-lifecycle.md +++ b/content/de/operations/cluster-lifecycle.md @@ -1,40 +1,40 @@ --- -title: "Cluster Lifecycle Operations" -description: "Plan, start, expand, rebalance, decommission, heal, and restart erasure-coded RustFS clusters with verified quorum and storage-class behavior." +title: "Cluster-Lebenszyklusoperationen" +description: "Planen, starten, erweitern und rebalancieren Sie RustFS-Cluster mit Erasure Coding, nehmen Sie sie außer Betrieb, stellen Sie Daten wieder her und starten Sie sie neu, mit geprüftem Verhalten von Quorum und Speicherklassen." --- -This runbook is the operator entry point for erasure-coded RustFS deployments: layout boundaries, storage classes and quorum, zero-parity mode, expansion, rebalancing, decommissioning, healing, drive replacement, and restarts. Every behavior described here was verified against the RustFS source; the upstream runbook in [rustfs/rustfs#7998](https://github.com/rustfs/rustfs/pull/7998) is the change that introduced it. +Dieses Runbook ist der Einstieg für den Betrieb von RustFS-Bereitstellungen mit Erasure Coding: Layoutgrenzen, Speicherklassen und Quorum, Null-Parität, Erweiterung, Rebalancing, Außerbetriebnahme, Datenwiederherstellung (Healing), Laufwerksaustausch und Neustarts. Jedes hier beschriebene Verhalten wurde gegen den RustFS-Quellcode geprüft. Das Upstream-Runbook in [rustfs/rustfs#7998](https://github.com/rustfs/rustfs/pull/7998) ist die Änderung, die es eingeführt hat. -Related task pages: [Storage Pool Expansion](./scaling/storage-pool-expansion.md), [Data Rebalancing](./scaling/data-rebalancing.md), [Storage Pool Decommission](./scaling/storage-pool-decommission.md), and [Node Healing](./high-availability/node-healing.md). +Verwandte Aufgabenseiten: [Speicherpool-Erweiterung](./scaling/storage-pool-expansion.md), [Daten-Rebalancing](./scaling/data-rebalancing.md), [Speicherpool-Außerbetriebnahme](./scaling/storage-pool-decommission.md) und [Datenwiederherstellung von Knoten](./high-availability/node-healing.md). -## Layout boundaries +## Layout-Beschränkungen -A pool's endpoint count, set count, drives per set, and position in the pool list are persisted layout. On startup RustFS compares the stored format with the configured drive count and set width and fails permanently with `PoolTopologyMismatch` (or `UnsupportedSnsdExpansion` for a single-drive deployment) instead of migrating. Restore the original endpoints and set width; do not delete `format.json` to get past the error. +Endpunktzahl, Set-Zahl, Laufwerke je Set und Position in der Poolliste eines Speicherpools sind persistiertes Layout. Beim Start vergleicht RustFS das gespeicherte Format mit der konfigurierten Laufwerkszahl und Set-Breite und schlägt dauerhaft mit `PoolTopologyMismatch` fehl (oder mit `UnsupportedSnsdExpansion` bei einer Bereitstellung mit einem Laufwerk), statt zu migrieren. Stellen Sie die ursprünglichen Endpunkte und die Set-Breite wieder her. Löschen Sie `format.json` nicht, um den Fehler zu umgehen. -:::warning[Never do these] +:::warning[Führen Sie Folgendes niemals aus] -- Overwrite an existing pool with more or fewer endpoints, or change `RUSTFS_ERASURE_SET_DRIVE_COUNT` for an initialized pool. -- Reorder volume arguments or move a drive directory to another slot. -- Delete, copy, or rename object shards, `xl.meta`, or anything under `.rustfs.sys` by hand. -- Treat a manual file copy as data movement. Only rebalance and decommission move objects, under object locks with version re-checks and source cleanup. +- Überschreiben Sie einen vorhandenen Speicherpool nicht mit mehr oder weniger Endpunkten und ändern Sie `RUSTFS_ERASURE_SET_DRIVE_COUNT` für einen initialisierten Speicherpool nicht. +- Ändern Sie die Reihenfolge der Volume-Argumente nicht und verschieben Sie ein Laufwerksverzeichnis nicht in einen anderen Slot. +- Löschen, kopieren oder benennen Sie Objekt-Shards, `xl.meta` oder etwas unter `.rustfs.sys` nicht von Hand um. +- Behandeln Sie ein manuelles Kopieren von Dateien nicht als Datenverschiebung. Nur Rebalancing und Außerbetriebnahme verschieben Objekte, unter Objektsperren, mit erneuter Versionsprüfung und mit Bereinigung der Quelle. ::: -Runtime roles: +Laufzeitrollen: -- **Pool** — one endpoint list with persisted layout. Multi-drive sets contain 2 to 16 drives; a single local path is the only single-drive layout. -- **Pool leader** — the first endpoint of a pool. Decommission start, cancel, and clear may be sent to any node; requests are forwarded to the pool leader over authenticated internode RPC. -- **Cluster-wide state** — rebalance and root heal propagate to peers and recover from persisted metadata on restart. +- **Pool:** eine Endpunktliste mit persistiertem Layout. Sets mit mehreren Laufwerken enthalten 2 bis 16 Laufwerke. Ein einzelner lokaler Pfad ist das einzige Layout mit einem Laufwerk. +- **Pool-Leader:** der erste Endpunkt eines Speicherpools. Start, Abbruch und Löschen einer Außerbetriebnahme dürfen an jeden Knoten gesendet werden. Die Anfragen werden über authentifizierte RPC zwischen den Knoten an den Pool-Leader weitergeleitet. +- **Clusterweiter Zustand:** Rebalancing und Root-Heal werden an Peers weitergegeben und stellen sich beim Neustart aus persistierten Metadaten wieder her. -## Plan and first start +## Planung und erster Start -1. Plan endpoints by node, rack, power, and network failure domain. Topology admission is not a high-availability guarantee: a single-node pool loses every shard with its host, and startup logs a `host_failure_data_unavailable` warning for every multi-drive pool. -2. Pick each pool's set width. Pools may differ in width, but each pool must split evenly into sets of one width from 2 to 16 drives; `RUSTFS_ERASURE_SET_DRIVE_COUNT` may pin a width that is already a valid divisor, nothing else. -3. Pick STANDARD and RRS parity per the rules in [Storage classes](#storage-classes-parity-and-quorum), then validate against the narrowest pool, because an explicit parity must fit every pool. -4. Record the full launch command, endpoint order, pool order, set width, and storage-class variables. They must be identical on every node and on every restart. -5. Give RustFS exclusive ownership of every endpoint path. +1. Planen Sie Endpunkte nach Knoten, Rack, Stromversorgung und Netzwerk-Fehlerdomäne. Die Annahme einer Topologie ist keine Hochverfügbarkeitszusage: Ein Speicherpool auf einem einzelnen Knoten verliert mit seinem Host jeden Shard, und der Start protokolliert für jeden Speicherpool mit mehreren Laufwerken eine Warnung `host_failure_data_unavailable`. +2. Wählen Sie die Set-Breite jedes Speicherpools. Die Breite darf sich zwischen Speicherpools unterscheiden, aber jeder Speicherpool muss sich gleichmäßig in Sets einer Breite von 2 bis 16 Laufwerken teilen. `RUSTFS_ERASURE_SET_DRIVE_COUNT` darf nur eine Breite festlegen, die bereits ein gültiger Teiler ist, sonst nichts. +3. Wählen Sie die Parität für STANDARD und RRS nach den Regeln unter [Speicherklassen](#speicherklassen-parität-und-quorum) und prüfen Sie sie gegen den schmalsten Speicherpool, weil eine explizite Parität in jeden Speicherpool passen muss. +4. Notieren Sie den vollständigen Startbefehl, die Endpunktreihenfolge, die Poolreihenfolge, die Set-Breite und die Variablen der Speicherklassen. Sie müssen auf jedem Knoten und bei jedem Neustart identisch sein. +5. Geben Sie RustFS das ausschließliche Eigentum an jedem Endpunktpfad. -Volumes come from positional arguments or `RUSTFS_VOLUMES`; `rustfs` with no arguments behaves as `rustfs server` with volumes from the environment. Ellipsis expansion follows the MinIO pattern: +Volumes stammen aus Positionsargumenten oder aus `RUSTFS_VOLUMES`. `rustfs` ohne Argumente verhält sich wie `rustfs server` mit Volumes aus der Umgebung. Die Expansion mit Auslassungspunkten folgt dem MinIO-Muster: ```bash # one pool, four nodes, four drives each: sixteen endpoints @@ -44,35 +44,35 @@ rustfs server http://node{1...4}:9000/data{1...4} rustfs server http://node{1...4}:9000/data{1...4} http://node{5...8}:9000/data{1...4} ``` -With more than one argument, every argument needs an ellipsis; each pool must expand to at least two distinct drive endpoints; a single-drive pool cannot join a multi-pool deployment; a singleton range such as `{3...3}` does not bypass the minimum. +Bei mehr als einem Argument braucht jedes Argument Auslassungspunkte. Jeder Speicherpool muss sich auf mindestens zwei unterschiedliche Laufwerksendpunkte ausdehnen. Ein Speicherpool mit einem Laufwerk kann keiner Bereitstellung mit mehreren Speicherpools beitreten. Ein Bereich mit einem einzigen Wert wie `{3...3}` umgeht das Minimum nicht. -A storage-class error stops startup before any disk is touched. Startup then initializes local disks, the lock clients, and the format quorum in that order. +Ein Fehler der Speicherklasse stoppt den Start, bevor ein Laufwerk berührt wird. Der Start initialisiert danach lokale Laufwerke, die Lock-Clients und das Format-Quorum, in dieser Reihenfolge. -## Startup configuration +## Startkonfiguration -| Variable | Effect | Boundary | +| Variable | Wirkung | Beschränkungen | |---|---|---| -| `RUSTFS_ERASURE_SET_DRIVE_COUNT` | Pin the set width | Must be a valid symmetric divisor of the pool, at most 16; cannot change an initialized pool | -| `RUSTFS_STORAGE_CLASS_STANDARD` | STANDARD parity as `EC:` | Validated per pool; affects new writes only | -| `RUSTFS_STORAGE_CLASS_RRS` | RRS parity as `EC:` | Validated per pool; an explicit value fails on a single drive, the persisted default `EC:1` resolves to `0` there | -| `RUSTFS_STORAGE_CLASS_OPTIMIZE` | Accepted for MinIO compatibility | Stored but currently unused: it changes nothing at runtime | -| `RUSTFS_STORAGE_CLASS_INLINE_BLOCK` | Fixed per-shard inline limit (bytesize syntax such as `128KiB`) | Replaces the scaled default in [Inline objects](#inline-objects); values above 128 KiB log a warning | +| `RUSTFS_ERASURE_SET_DRIVE_COUNT` | Legt die Set-Breite fest | Muss ein gültiger symmetrischer Teiler des Speicherpools sein, höchstens 16. Kann einen initialisierten Speicherpool nicht ändern | +| `RUSTFS_STORAGE_CLASS_STANDARD` | STANDARD-Parität als `EC:` | Wird je Speicherpool geprüft. Wirkt nur auf neue Schreibvorgänge | +| `RUSTFS_STORAGE_CLASS_RRS` | RRS-Parität als `EC:` | Wird je Speicherpool geprüft. Ein expliziter Wert schlägt auf einem einzelnen Laufwerk fehl. Der persistierte Standard `EC:1` wird dort zu `0` aufgelöst | +| `RUSTFS_STORAGE_CLASS_OPTIMIZE` | Wird aus MinIO-Kompatibilität akzeptiert | Wird gespeichert, ist derzeit aber ungenutzt: Zur Laufzeit ändert es nichts | +| `RUSTFS_STORAGE_CLASS_INLINE_BLOCK` | Feste Inline-Grenze je Shard (Bytesize-Syntax wie `128KiB`) | Ersetzt den skalierten Standard unter [Inline-Objekte](#inline-objekte). Werte über 128 KiB erzeugen eine Warnung im Protokoll | -An empty `RUSTFS_STORAGE_CLASS_STANDARD` or `RUSTFS_STORAGE_CLASS_RRS` restores the automatic policy and overrides a persisted value. `MINIO_`-prefixed spellings of these keys, of `ERASURE_SET_DRIVE_COUNT`, and of `VOLUMES` are mapped onto the `RUSTFS_` names when the `RUSTFS_` name is unset; when both are set the `RUSTFS_` value wins and the conflict is reported at startup. +Ein leeres `RUSTFS_STORAGE_CLASS_STANDARD` oder `RUSTFS_STORAGE_CLASS_RRS` stellt die automatische Richtlinie wieder her und überschreibt einen persistierten Wert. Schreibweisen dieser Schlüssel, von `ERASURE_SET_DRIVE_COUNT` und von `VOLUMES` mit dem Präfix `MINIO_` werden auf die Namen mit `RUSTFS_` abgebildet, wenn der Name mit `RUSTFS_` nicht gesetzt ist. Wenn beide gesetzt sind, gilt der Wert mit `RUSTFS_`, und der Konflikt wird beim Start gemeldet. -Other data-movement and listing knobs: `RUSTFS_REBALANCE_MAX_ATTEMPTS` (default 3), `RUSTFS_DECOMMISSION_BUCKET_CONCURRENCY` (default cap 4), `RUSTFS_DECOMMISSION_ENTRY_CONCURRENCY` (default cap 8, hard cap 64), and `RUSTFS_LIST_OBJECTS_QUORUM` (default `optimal`; accepts `disk`, `reduced`, `optimal`, `auto`, anything else means `strict`). None of them relaxes object quorum, object locks, or version checks. +Weitere Stellgrößen für Datenverschiebung und Auflistung: `RUSTFS_REBALANCE_MAX_ATTEMPTS` (Standard 3), `RUSTFS_DECOMMISSION_BUCKET_CONCURRENCY` (Standardobergrenze 4), `RUSTFS_DECOMMISSION_ENTRY_CONCURRENCY` (Standardobergrenze 8, harte Obergrenze 64) und `RUSTFS_LIST_OBJECTS_QUORUM` (Standard `optimal`; akzeptiert `disk`, `reduced`, `optimal`, `auto`, alles andere bedeutet `strict`). Keine davon lockert Objekt-Quorum, Objektsperren oder Versionsprüfungen. -## Storage classes, parity, and quorum +## Speicherklassen, Parität und Quorum -### Geometry +### Geometrie -Each object is Reed-Solomon coded across the `N` drives of one set into `K` data and `M` parity shards, `N = K + M`; any `K` shards rebuild it. The geometry is stored per object in `xl.meta`, so changing the default later rewrites nothing. Objects hash to a set and shards rotate within it; sets never share a failure budget. +Jedes Objekt wird mit Reed-Solomon über die `N` Laufwerke eines Sets in `K` Daten-Shards und `M` Paritäts-Shards codiert, `N = K + M`. Beliebige `K` Shards stellen es wieder her. Die Geometrie wird je Objekt in `xl.meta` gespeichert. Eine spätere Änderung des Standards schreibt deshalb nichts um. Objekte werden einem Set per Hash zugeordnet, und die Shards rotieren innerhalb dieses Sets. Sets teilen sich nie ein Fehlerbudget. -Default STANDARD parity by set width: 0 for one drive, 1 for 2 to 3, 2 for 4 to 5, 3 for 6 to 7, 4 for 8 to 16. Default RRS parity is 1 (0 on a single drive). +Standardparität für STANDARD nach Set-Breite: 0 bei einem Laufwerk, 1 bei 2 bis 3, 2 bei 4 bis 5, 3 bei 6 bis 7, 4 bei 8 bis 16. Die Standardparität für RRS ist 1 (0 auf einem einzelnen Laufwerk). -Validation rules: each parity is at most `N/2` for every pool, and STANDARD parity is at least RRS parity only when both are non-zero. There is no minimum, so `EC:0` passes on any width. Only `STANDARD` and `REDUCED_REDUNDANCY` are accepted on PUT, CopyObject, and CreateMultipartUpload; other AWS storage classes return `InvalidStorageClass`. +Prüfregeln: Jede Parität beträgt für jeden Speicherpool höchstens `N/2`, und die STANDARD-Parität ist nur dann mindestens die RRS-Parität, wenn beide ungleich null sind. Ein Minimum gibt es nicht, deshalb besteht `EC:0` auf jeder Breite. Bei PUT, CopyObject und CreateMultipartUpload werden nur `STANDARD` und `REDUCED_REDUNDANCY` akzeptiert. Andere AWS-Speicherklassen liefern `InvalidStorageClass`. -### Quorum and capacity +### Quorum und Kapazität ```text usable capacity ≈ raw × K / N @@ -81,38 +81,38 @@ write quorum = K, or K + 1 when K == M delete markers = N/2 + 1 (majority, both write and vote) ``` -Sixteen drives at `EC:4`: `K = 12`, about 75 percent usable, four failures tolerated, twelve valid shards needed to read. Two drives at `EC:1`: `K = M = 1`, so one drive down still reads but no longer writes. Internal metadata under `.rustfs.sys` is always written with parity `N/2`, regardless of the configured class. +Sechzehn Laufwerke bei `EC:4`: `K = 12`, etwa 75 Prozent nutzbar, vier Ausfälle toleriert, zwölf gültige Shards zum Lesen erforderlich. Zwei Laufwerke bei `EC:1`: `K = M = 1`, ein ausgefallenes Laufwerk liest also noch, schreibt aber nicht mehr. Interne Metadaten unter `.rustfs.sys` werden immer mit der Parität `N/2` geschrieben, unabhängig von der konfigurierten Klasse. -### Inline objects +### Inline-Objekte -An object is stored inline in `xl.meta` when every shard is at most the per-shard budget. The default budget is `256 KiB / K` capped at 128 KiB per shard, so a wider set does not raise the maximum inline object size; on a versioned bucket the budget is divided by 8. `RUSTFS_STORAGE_CLASS_INLINE_BLOCK` replaces the scaled default with a fixed per-shard limit. Each drive keeps only its own shard inline, so inline data has the same loss semantics as external shards. Compressed or encrypted streams inline only when the stored size is known and within budget. +Ein Objekt wird inline in `xl.meta` gespeichert, wenn jeder Shard höchstens das Budget je Shard erreicht. Das Standardbudget ist `256 KiB / K`, gedeckelt auf 128 KiB je Shard. Ein breiteres Set erhöht deshalb die maximale Größe eines Inline-Objekts nicht. In einem Bucket mit Versionierung wird das Budget durch 8 geteilt. `RUSTFS_STORAGE_CLASS_INLINE_BLOCK` ersetzt den skalierten Standard durch eine feste Grenze je Shard. Jedes Laufwerk behält nur seinen eigenen Shard inline. Inline-Daten haben deshalb dieselbe Verlustsemantik wie externe Shards. Komprimierte oder verschlüsselte Ströme werden nur inline gespeichert, wenn die gespeicherte Größe bekannt und innerhalb des Budgets ist. -### Write and read paths +### Schreib- und Lesepfade -Writes resolve the layout per pool, encode with Reed-Solomon in 1 MiB blocks, write bitrot-protected shards, and commit only after write quorum. A write below quorum is never reported as success. Reads pick the authoritative metadata at read quorum, verify bitrot, decode from at least `K` shards, and fail closed below that; a read that succeeds with missing shards enqueues read-repair. Multipart parts use the object's geometry and write quorum; `CompleteMultipartUpload` re-checks metadata and commit quorum, so an uploaded part is not a committed object. +Schreibvorgänge lösen das Layout je Speicherpool auf, codieren mit Reed-Solomon in Blöcken von 1 MiB, schreiben gegen Bitrot geschützte Shards und schreiben sie erst nach Schreibquorum fest. Ein Schreibvorgang unterhalb des Quorums wird niemals als Erfolg gemeldet. Lesevorgänge wählen die maßgeblichen Metadaten beim Lesequorum, prüfen Bitrot, decodieren aus mindestens `K` Shards und lehnen den Vorgang ab, wenn weniger Shards vorliegen. Ein Lesevorgang, der mit fehlenden Shards gelingt, reiht eine Lesereparatur ein. Teile eines mehrteiligen Uploads verwenden die Geometrie und das Schreibquorum des Objekts. `CompleteMultipartUpload` prüft Metadaten und das Quorum für das Festschreiben erneut. Ein hochgeladener Teil ist deshalb kein festgeschriebenes Objekt. -## Zero parity (EC:0) +## Null-Parität (EC:0) -`EC:0` is accepted for STANDARD, for RRS, or for both, on any set width. It gives raw capacity and no redundancy. +`EC:0` wird für STANDARD, für RRS oder für beide auf jeder Set-Breite akzeptiert. Es liefert Rohkapazität und keine Redundanz. -:::danger[EC:0 means one drive loss equals set loss] +:::danger[Bei EC:0 geht mit einem Laufwerksverlust der Datenbestand im Set verloren] -A replaced or wiped drive permanently loses every zero-parity object that had a shard on it, unless a copy exists outside the set. Healing cannot rebuild zero-parity objects: heal reports `no-parity object is unrecoverable` for them. Production deployments should use `EC:1` or higher; `EC:2` or more per set is the usual floor once a set spans more than one node. Use `EC:0` only where an external layer (RAID, replication, backup, or a re-creatable source) owns durability and availability, and only with explicit sign-off. +Ein ersetztes oder gelöschtes Laufwerk verliert dauerhaft jedes Objekt mit Null-Parität, das einen Shard darauf hatte, sofern außerhalb des Sets keine Kopie existiert. Die Datenwiederherstellung kann Objekte mit Null-Parität nicht wiederaufbauen. Sie meldet für sie `no-parity object is unrecoverable`. Produktivbereitstellungen sollten `EC:1` oder höher verwenden. Sobald ein Set mehr als einen Knoten umfasst, ist `EC:2` oder mehr je Set die übliche Untergrenze. Verwenden Sie `EC:0` nur dort, wo eine externe Schicht (RAID, Replikation, Sicherung oder eine neu erzeugbare Quelle) Haltbarkeit und Verfügbarkeit trägt, und nur mit ausdrücklicher Freigabe. ::: -Behavior details: +Verhaltensdetails: -- **Configuration.** Explicit `EC:0` produces no startup warning — the zero-redundancy warning fires only for automatic zero parity, meaning a single-drive pool. `STANDARD=EC:2` with `RRS=EC:0` is valid because the ordering rule is skipped when either side is zero; only objects written with `x-amz-storage-class: REDUCED_REDUNDANCY` then carry zero-parity semantics. -- **Writes.** Write quorum is `N`: if any drive of the set is unwritable, the write fails with `ErasureWriteQuorum` and nothing is committed. Because a zero-parity shard cannot be rebuilt later, the write path verifies every shard it just wrote against its bitrot hash before commit and refuses to commit a shard that already fails. -- **Reads.** Read quorum is `N`. With any drive of the set offline, HEAD and GET of every zero-parity object in that set fail with `ErasureReadQuorum`. There is no degraded read. -- **Deletes.** Delete markers and version deletes use majority quorum (`N/2 + 1`), so a delete can succeed on a set whose reads and writes are failing. A successful delete is not evidence that the set is healthy. -- **What still works with one drive down.** Bucket operations, `.rustfs.sys` metadata, delete markers, and listings that satisfy the list quorum. Everything else in the set is unavailable, including rebalance and decommission of its objects, which must read all `N` shards. -- **Raising parity later rewrites nothing.** Re-upload or server-side copy each object after the change to re-protect it. +- **Konfiguration.** Explizites `EC:0` erzeugt keine Startwarnung. Die Warnung zur fehlenden Redundanz erscheint nur bei automatischer Null-Parität, also bei einem Speicherpool mit einem Laufwerk. `STANDARD=EC:2` mit `RRS=EC:0` ist gültig, weil die Ordnungsregel entfällt, wenn eine Seite null ist. Nur Objekte, die mit `x-amz-storage-class: REDUCED_REDUNDANCY` geschrieben werden, tragen dann die Semantik der Null-Parität. +- **Schreibvorgänge.** Das Schreibquorum ist `N`: Wenn irgendein Laufwerk des Sets nicht beschreibbar ist, schlägt der Schreibvorgang mit `ErasureWriteQuorum` fehl, und es wird nichts festgeschrieben. Weil ein Shard mit Null-Parität später nicht wiederaufgebaut werden kann, prüft der Schreibpfad jeden gerade geschriebenen Shard vor dem Festschreiben gegen seinen Bitrot-Hash und verweigert das Festschreiben eines Shards, der bereits fehlschlägt. +- **Lesevorgänge.** Das Lesequorum ist `N`. Ist irgendein Laufwerk des Sets offline, schlagen HEAD und GET jedes Objekts mit Null-Parität in diesem Set mit `ErasureReadQuorum` fehl. Einen eingeschränkten Lesevorgang gibt es nicht. +- **Löschvorgänge.** Löschmarkierungen und Versionslöschungen verwenden Mehrheitsquorum (`N/2 + 1`). Ein Löschvorgang kann deshalb auf einem Set gelingen, dessen Lese- und Schreibvorgänge fehlschlagen. Ein erfolgreicher Löschvorgang belegt nicht, dass das Set intakt ist. +- **Was bei einem ausgefallenen Laufwerk noch funktioniert.** Bucket-Operationen, Metadaten unter `.rustfs.sys`, Löschmarkierungen und Auflistungen, die das Listen-Quorum erfüllen. Alles andere im Set ist nicht verfügbar, einschließlich Rebalancing und Außerbetriebnahme seiner Objekte, die alle `N` Shards lesen müssen. +- **Ein späteres Anheben der Parität schreibt nichts um.** Laden Sie jedes Objekt nach der Änderung erneut hoch oder kopieren Sie es serverseitig, um es wieder zu schützen. -## Post-start verification +## Überprüfung nach dem Start -Read-only admin checks: +Schreibgeschützte Admin-Prüfungen: ```text GET /rustfs/admin/v3/pools/list @@ -122,27 +122,27 @@ GET /rustfs/admin/v4/cluster/snapshot GET /rustfs/admin/v4/runtime/capabilities ``` -`pool` is a pool command line, or a zero-based index with `by-id=true`. Status queries ignore unknown parameters; mutation queries reject unknown or duplicate parameters and a `by-id` value other than `true` or `false`. +`pool` ist eine Pool-Befehlszeile oder ein nullbasierter Index mit `by-id=true`. Statusabfragen ignorieren unbekannte Parameter. Ändernde Abfragen lehnen unbekannte oder doppelte Parameter ab sowie einen Wert von `by-id`, der nicht `true` oder `false` ist. -Confirm: pool count, endpoints per pool, set count and width per pool, local versus remote endpoints, and no topology mismatch. +Bestätigen Sie: Poolzahl, Endpunkte je Speicherpool, Set-Zahl und Breite je Speicherpool, lokale gegenüber entfernten Endpunkten und keine Topologieabweichung. -Data-plane checks: write one STANDARD and one RRS object; GET, HEAD, range GET, CopyObject, and a multipart upload; take one drive or node offline within parity and confirm reads continue and writes behave per the quorum table; bring it back and confirm the heal queue drains and bitrot errors stop; confirm every node reports the same pool metadata and cluster snapshot. +Prüfungen der Datenebene: Schreiben Sie ein STANDARD- und ein RRS-Objekt. Führen Sie GET, HEAD, Bereichs-GET, CopyObject und einen mehrteiligen Upload aus. Nehmen Sie ein Laufwerk oder einen Knoten innerhalb der Parität offline und bestätigen Sie, dass Lesevorgänge weiterlaufen und Schreibvorgänge der Quorum-Tabelle entsprechen. Bringen Sie es zurück und bestätigen Sie, dass sich die Heal-Warteschlange leert und Bitrot-Fehler aufhören. Bestätigen Sie, dass jeder Knoten dieselben Pool-Metadaten und denselben Cluster-Snapshot meldet. -## Expansion +## Erweiterung -An existing pool cannot grow in place. Add a pool: +Ein vorhandener Speicherpool kann nicht an Ort und Stelle wachsen. Fügen Sie einen Speicherpool hinzu: -1. Plan its nodes, drives, and failure domain; each new pool needs at least two drive endpoints and its own valid set layout. -2. Prepare empty, RustFS-exclusive paths on every node. -3. Append the pool to the launch arguments on **every** node, keeping existing pools, their order, endpoints, and set width unchanged. A single-node single-drive deployment cannot expand; migrate through S3 instead. -4. Restart and verify per the checks above. -5. New writes are placed across available pools; old objects stay where they are. To move them, start a rebalance. A restart never rebalances. +1. Planen Sie seine Knoten, Laufwerke und Fehlerdomäne. Jeder neue Speicherpool braucht mindestens zwei Laufwerksendpunkte und ein eigenes gültiges Set-Layout. +2. Bereiten Sie auf jedem Knoten leere Pfade vor, die ausschließlich RustFS gehören. +3. Hängen Sie den Speicherpool auf **jedem** Knoten an die Startargumente an und lassen Sie vorhandene Speicherpools, ihre Reihenfolge, Endpunkte und Set-Breite unverändert. Eine Bereitstellung mit einem Knoten und einem Laufwerk kann nicht erweitert werden. Migrieren Sie stattdessen über S3. +4. Starten Sie neu und prüfen Sie gemäß den Prüfungen oben. +5. Neue Schreibvorgänge werden über die verfügbaren Speicherpools verteilt. Alte Objekte bleiben, wo sie sind. Um sie zu verschieben, starten Sie ein Rebalancing. Ein Neustart führt niemals ein Rebalancing aus. -Adding a pool does not add parity to existing objects and does not copy anything. Cross-pool movement is rebalance or decommission only. See [Storage Pool Expansion](./scaling/storage-pool-expansion.md) for a worked example. +Das Hinzufügen eines Speicherpools fügt vorhandenen Objekten keine Parität hinzu und kopiert nichts. Bewegung zwischen Speicherpools erfolgt nur durch Rebalancing oder Außerbetriebnahme. Ein ausgearbeitetes Beispiel steht unter [Speicherpool-Erweiterung](./scaling/storage-pool-expansion.md). -## Rebalance +## Rebalancing -Rebalance redistributes objects across pools by usage. Preconditions: more than one pool (a single pool returns `NotImplemented`), no decommission running or conflicting, and no query string on `start` or `stop`. +Rebalancing verteilt Objekte nach Nutzung über die Speicherpools neu. Vorbedingungen: mehr als ein Speicherpool (ein einzelner Speicherpool liefert `NotImplemented`), keine laufende oder im Konflikt stehende Außerbetriebnahme und keine Abfragezeichenfolge bei `start` oder `stop`. ```text POST /rustfs/admin/v3/rebalance/start → {"id": ""} @@ -150,13 +150,13 @@ GET /rustfs/admin/v3/rebalance/status POST /rustfs/admin/v3/rebalance/stop ``` -Status reports per-pool `id`, `status`, `stopping`, `used`, `lastError`, `cleanupWarnings`, and `progress` (objects, versions, bytes, remaining buckets, current bucket and object, elapsed, ETA), plus `stoppedAt` and stop-propagation fields. +Der Status meldet je Speicherpool `id`, `status`, `stopping`, `used`, `lastError`, `cleanupWarnings` und `progress` (Objekte, Versionen, Bytes, verbleibende Buckets, aktueller Bucket und aktuelles Objekt, vergangene Zeit, ETA) sowie `stoppedAt` und Felder zur Stopp-Weitergabe. -Start propagates an admission fence and worker state to peers; a propagation failure rolls back to a terminal state and reports any peer that did not roll back. Stop closes admission, stops local and remote workers, and persists the stopped state. Treat a rebalance as finished only when no pool is active or stopping, `lastError` is empty or explained, `cleanupWarnings` are understood, stop propagation has completed, and migrated objects read from their new pool. Per-pool state lives in `rebalance.bin`; never delete it to unblock a run. See [Data Rebalancing](./scaling/data-rebalancing.md) for the walkthrough. +Start gibt eine Sperre für neue Zulassungen und den Worker-Zustand an die Peers weiter. Schlägt die Weitergabe fehl, wird auf einen Endzustand zurückgerollt, und jeder Peer, der nicht zurückgerollt ist, wird gemeldet. Stop schließt die Zulassung, stoppt lokale und entfernte Worker und persistiert den gestoppten Zustand. Behandeln Sie ein Rebalancing nur dann als abgeschlossen, wenn kein Speicherpool aktiv ist oder stoppt, `lastError` leer oder erklärt ist, `cleanupWarnings` verstanden sind, die Stopp-Weitergabe abgeschlossen ist und migrierte Objekte aus ihrem neuen Speicherpool gelesen werden können. Der Zustand je Speicherpool liegt in `rebalance.bin`. Löschen Sie die Datei niemals, um einen Lauf freizugeben. Die Durchführung steht unter [Daten-Rebalancing](./scaling/data-rebalancing.md). -## Decommission +## Außerbetriebnahme -Operator summary — supported only on multi-pool, non-legacy (ellipsis) deployments; anything else returns `NotImplemented`. A rebalance in progress blocks start. +Kurz für den Betrieb: nur bei Bereitstellungen mit mehreren Speicherpools unterstützt, die das Format mit Auslassungspunkten verwenden. Alles andere liefert `NotImplemented`. Ein laufendes Rebalancing blockiert den Start. ```text POST /rustfs/admin/v3/pools/decommission?pool=[,] # by command line @@ -166,17 +166,17 @@ POST /rustfs/admin/v3/pools/cancel?pool=1&by-id=true POST /rustfs/admin/v3/pools/clear?pool=1&by-id=true ``` -- Targets are validated as a batch before anything is persisted: unknown, duplicate, active, queued, or completed targets are rejected; failed or canceled targets must be cleared first unless they hold unresolved listing entries, in which case a new start is the retry path. -- Entry states: `queued` → `active` → `completed`, `failed`, or `canceled`, persisted in `pool.bin`. Startup resumes non-terminal entries and skips terminal predecessors. -- A source pool in any decommission state rejects new ordinary PUTs and new multipart uploads (a staged PUT gets `SlowDown`); existing multipart uploads may drain while the source is non-terminal. -- `clear` removes failed or canceled metadata only and never moves data back. -- Remove a pool from the launch arguments only after its entry is `completed`, free versions and tier ownership have converged, and every node shows the same status. Never detach source drives before that, and never substitute a directory delete for the configuration change. +- Ziele werden als Stapel geprüft, bevor etwas persistiert wird. Unbekannte, doppelte, aktive, eingereihte oder abgeschlossene Ziele werden abgelehnt. Fehlgeschlagene oder abgebrochene Ziele müssen zuerst gelöscht werden, außer sie enthalten unaufgelöste Auflistungseinträge. Dann ist ein neuer Start der Pfad für einen erneuten Versuch. +- Zustände der Einträge: `queued` → `active` → `completed`, `failed` oder `canceled`, persistiert in `pool.bin`. Der Start setzt Einträge fort, die noch keinen Endzustand haben, und überspringt vorangehende Einträge im Endzustand. +- Ein Quellpool in irgendeinem Außerbetriebszustand lehnt neue gewöhnliche PUTs und neue mehrteilige Uploads ab (ein bereits begonnener PUT erhält `SlowDown`). Vorhandene mehrteilige Uploads dürfen abfließen, solange die Quelle nicht endgültig ist. +- `clear` entfernt nur Metadaten fehlgeschlagener oder abgebrochener Vorgänge und verschiebt niemals Daten zurück. +- Entfernen Sie einen Speicherpool erst dann aus den Startargumenten, wenn sein Eintrag `completed` ist, freie Versionen und die Tier-Zugehörigkeit zusammengeführt sind und jeder Knoten denselben Status zeigt. Trennen Sie Quelllaufwerke niemals vorher, und ersetzen Sie die Konfigurationsänderung niemals durch das Löschen eines Verzeichnisses. -See [Storage Pool Decommission](./scaling/storage-pool-decommission.md) for the walkthrough. +Die Durchführung steht unter [Speicherpool-Außerbetriebnahme](./scaling/storage-pool-decommission.md). -## Heal and drive replacement +## Datenwiederherstellung und Laufwerksaustausch -### Admin heal +### Admin-Heal ```text POST /rustfs/admin/v3/heal/ # root: cluster, or one erasure set with pool+set @@ -186,59 +186,59 @@ POST /rustfs/admin/v3/background-heal/status GET /rustfs/admin/v4/heal/replacement-recovery ``` -The JSON body carries `recursive`, `dryRun`, `remove`, `recreate`, `scanMode`, `updateParity`, `nolock`, `readRepair`, `pool`, and `set`. Handler rules: +Der JSON-Body trägt `recursive`, `dryRun`, `remove`, `recreate`, `scanMode`, `updateParity`, `nolock`, `readRepair`, `pool` und `set`. Regeln der Verarbeitung: -- a root heal must set `recursive=true` or name both `pool` and `set`; a bucket heal without a prefix is always recursive, and a prefix heal honors `recursive`; -- `readRepair=true` is rejected with `InvalidArgument`; -- `nolock` is accepted on the wire but always forced to `false` — admin heals always take the object namespace lock, so there is no lock bypass; -- `clientToken` correlates start, status, and stop; `forceStart` and `forceStop` are validated against it, and unknown or duplicate query keys are rejected. +- Ein Root-Heal muss `recursive=true` setzen oder sowohl `pool` als auch `set` nennen. Ein Bucket-Heal ohne Präfix ist immer rekursiv, und ein Präfix-Heal beachtet `recursive`. +- `readRepair=true` wird mit `InvalidArgument` abgelehnt. +- `nolock` wird auf der Leitung akzeptiert, aber immer auf `false` gezwungen. Admin-Heals nehmen immer die Sperre des Objekt-Namensraums. Eine Umgehung der Sperre gibt es nicht. +- `clientToken` verknüpft Start, Status und Stopp. `forceStart` und `forceStop` werden dagegen geprüft, und unbekannte oder doppelte Abfrageschlüssel werden abgelehnt. -Heal selects the authoritative version from quorum metadata and refuses when more shards are missing than parity can rebuild or when the stored geometry does not match the set. It shares the `(bucket, object)` lock with PUT, delete, multipart complete, and data movement. +Die Datenwiederherstellung wählt die maßgebliche Version aus den Quorum-Metadaten und verweigert den Vorgang, wenn mehr Shards fehlen, als die Parität wiederaufbauen kann, oder wenn die gespeicherte Geometrie nicht zum Set passt. Sie teilt die Sperre `(bucket, object)` mit PUT, Löschen, Abschluss eines mehrteiligen Uploads und Datenverschiebung. -### Drive replacement +### Laufwerksaustausch -1. Confirm the affected set still meets read quorum for its objects (impossible at `EC:0`) and record pool index, set index, slot, and the failed disk's UUID from the pool status. -2. Replace the drive at the **same** endpoint and mount path with an empty filesystem owned by RustFS. Do not copy the old drive's directories; a copied `format.json` claims an identity the set already tracks. -3. Bring the node back. The empty drive is not a format-quorum member, so its slot stays offline until the erasure-set heal task writes the format into the original slot and rebuilds the shards — through the recorded automatic replacement intent when startup or the disk scanner observes a changed mount identity, or through an admin erasure-set heal (`POST /rustfs/admin/v3/heal/` with `pool` and `set`). -4. Watch `GET /rustfs/admin/v4/heal/replacement-recovery`, background heal status, disk health, and bitrot counters. An `idle` queue or a readable object is not proof of completion. -5. The replacement is done when recovery reports `completed` for that instance and sampled objects have `xl.meta` and parts on the new drive. +1. Bestätigen Sie, dass das betroffene Set für seine Objekte noch das Lesequorum erfüllt (bei `EC:0` unmöglich), und notieren Sie Pool-Index, Set-Index, Slot und die UUID des ausgefallenen Laufwerks aus dem Poolstatus. +2. Ersetzen Sie das Laufwerk am **selben** Endpunkt und Einhängepfad durch ein leeres Dateisystem, das RustFS gehört. Kopieren Sie die Verzeichnisse des alten Laufwerks nicht. Eine kopierte `format.json` beansprucht eine Identität, die das Set bereits führt. +3. Bringen Sie den Knoten zurück. Das leere Laufwerk ist kein Mitglied des Format-Quorums, deshalb bleibt sein Slot offline, bis die Heal-Aufgabe des Erasure-Sets das Format in den ursprünglichen Slot schreibt und die Shards wiederaufbaut. Das geschieht über die aufgezeichnete automatische Ersatzabsicht, wenn der Start oder der Laufwerksscanner eine geänderte Einhängeidentität erkennt, oder über einen Admin-Heal des Erasure-Sets (`POST /rustfs/admin/v3/heal/` mit `pool` und `set`). +4. Beobachten Sie `GET /rustfs/admin/v4/heal/replacement-recovery`, den Status der Hintergrund-Datenwiederherstellung, die Laufwerksintegrität und die Bitrot-Zähler. Eine Warteschlange mit `idle` oder ein lesbares Objekt belegt den Abschluss nicht. +5. Der Austausch ist abgeschlossen, wenn die Wiederherstellung für diese Instanz `completed` meldet und stichprobenartig geprüfte Objekte `xl.meta` und Teile auf dem neuen Laufwerk haben. -If a set has lost more drives than its parity, heal cannot rebuild; recover from replication, a remote tier, or backup. See [Node Healing](./high-availability/node-healing.md) for the broader healing model. +Wenn ein Set mehr Laufwerke verloren hat, als seine Parität abdeckt, kann die Datenwiederherstellung nichts wiederaufbauen. Stellen Sie die Daten aus der Replikation, einer entfernten Stufe oder einer Sicherung wieder her. Das umfassendere Modell der Datenwiederherstellung steht unter [Datenwiederherstellung von Knoten](./high-availability/node-healing.md). -## Restart and recovery +## Neustart und Wiederherstellung -- **Ordinary restart.** No topology change in flight, identical arguments on every node, one node at a time. Startup reloads pool metadata, `rebalance.bin`, the decommission queue, and heal recovery records, and resumes workers by leader and owner rules. -- **Rebalance.** Read `/rebalance/status` first. Handle active or stopping pools, `lastError`, cleanup warnings, and stop propagation before deciding to stop or restart. Do not delete `rebalance.bin`. -- **Decommission.** Non-terminal entries resume; failed and canceled entries survive restarts until cleared or retried through the allowed path. -- **Root heal.** A graceful shutdown persists an unfinished cluster heal as `root-heal-.json` under `.rustfs.sys` and replays it with the same task id. Invalid, oversized, or unsupported records move to quarantine prefixes and are skipped with a log line until an operator repairs them. Do not delete quarantine markers or reuse a task id. -- **Unclean shutdown.** When the previous run left its marker behind, the heal manager enqueues a full erasure-set heal for every local set; graceful shutdown clears the marker. +- **Gewöhnlicher Neustart.** Keine laufende Topologieänderung, identische Argumente auf jedem Knoten, jeweils ein Knoten. Der Start lädt Pool-Metadaten, `rebalance.bin`, die Außerbetriebnahme-Warteschlange und die Wiederherstellungsdatensätze des Heal neu und setzt Worker nach den Regeln für Leader und Eigentümer fort. +- **Rebalancing.** Lesen Sie zuerst `/rebalance/status`. Behandeln Sie aktive oder stoppende Speicherpools, `lastError`, Bereinigungswarnungen und die Stopp-Weitergabe, bevor Sie sich für Stopp oder Neustart entscheiden. Löschen Sie `rebalance.bin` nicht. +- **Außerbetriebnahme.** Nicht endgültige Einträge werden fortgesetzt. Fehlgeschlagene und abgebrochene Einträge überdauern Neustarts, bis sie gelöscht oder über den zulässigen Pfad erneut versucht werden. +- **Root-Heal.** Ein geordnetes Herunterfahren persistiert eine unfertige clusterweite Datenwiederherstellung als `root-heal-.json` unter `.rustfs.sys` und spielt sie mit derselben Aufgaben-ID erneut ab. Ungültige, zu große oder nicht unterstützte Datensätze wandern in Quarantäne-Präfixe und werden mit einer Protokollzeile übersprungen, bis der Betrieb sie repariert. Löschen Sie Quarantäne-Markierungen nicht und verwenden Sie eine Aufgaben-ID nicht erneut. +- **Unsauberes Herunterfahren.** Wenn der vorherige Lauf seine Markierung hinterlassen hat, reiht der Heal-Manager für jedes lokale Set eine vollständige Datenwiederherstellung des Erasure-Sets ein. Ein geordnetes Herunterfahren löscht die Markierung. -## Mutual exclusion and prohibited actions +## Gegenseitiger Ausschluss und unzulässige Aktionen -| Operation | With rebalance | With decommission | Notes | +| Vorgang | Mit Rebalancing | Mit Außerbetriebnahme | Hinweise | |---|---|---|---| -| PUT, DELETE, multipart complete | Object lock | Source pool rejects new publication | Never bypass the pool fence | -| Decommission | Rejected while rebalance runs | Serial queue | Leader-only mutation | -| Rebalance | Multi-pool only | Rejected while decommission runs or conflicts | No query parameters | -| Admin heal | Object lock | Repairs data, never changes decommission state | `nolock` is ignored | -| Drive replacement | Cannot change the layout | Avoid on a source pool mid-decommission | Same slot, empty drive | +| PUT, DELETE, Abschluss eines mehrteiligen Uploads | Objektsperre | Der Quellpool lehnt neue Veröffentlichung ab | Umgehen Sie die Poolsperre niemals | +| Außerbetriebnahme | Abgelehnt, solange Rebalancing läuft | Serielle Warteschlange | Änderung nur durch den Leader | +| Rebalancing | Nur bei mehreren Speicherpools | Abgelehnt, solange eine Außerbetriebnahme läuft oder im Konflikt steht | Keine Abfrageparameter | +| Admin-Heal | Objektsperre | Repariert Daten, ändert den Außerbetriebszustand niemals | `nolock` wird ignoriert | +| Laufwerksaustausch | Kann das Layout nicht ändern | Vermeiden Sie ihn auf einem Quellpool während der Außerbetriebnahme | Derselbe Slot, leeres Laufwerk | -:::warning[Prohibited] +:::warning[Unzulässig] -Do not change launch endpoints while rebalance or decommission runs; do not delete `.rustfs.sys`, `rebalance.bin`, `pool.bin`, or root-heal records; do not run manual heal, file copies, and drive replacement on one pool at the same time; do not treat an HTTP 200 on a start call as completion. +Ändern Sie Start-Endpunkte nicht, solange Rebalancing oder Außerbetriebnahme läuft. Löschen Sie `.rustfs.sys`, `rebalance.bin`, `pool.bin` oder Root-Heal-Datensätze nicht. Führen Sie manuelle Datenwiederherstellung, Dateikopien und Laufwerksaustausch nicht gleichzeitig auf einem Speicherpool aus. Werten Sie ein HTTP 200 bei einem Startaufruf nicht als Abschluss. ::: -## Checklists +## Checklisten -- **After start or expansion**: identical endpoints and pool order on every node; topology equals the stored format; peers ready; new endpoints unique and RustFS-exclusive; GET, HEAD, range GET, and multipart verified. -- **After rebalance**: no pool active or stopping; `lastError` empty or explained; `cleanupWarnings` handled; stop propagation complete; migrated objects readable. -- **After decommission**: status `completed`; other entries handled by policy; source pool rejects new writes; free versions, tier ownership, and listing entries converged; launch arguments updated on every node before drives are detached. -- **After heal or replacement**: replacement recovery `completed`; slot and UUID correct; heal queue drained; no growing bitrot count; sampled current and historical versions readable; no leftover temporary directories. +- **Nach Start oder Erweiterung:** identische Endpunkte und Poolreihenfolge auf jedem Knoten; Topologie entspricht dem gespeicherten Format; Peers bereit; neue Endpunkte eindeutig und ausschließlich für RustFS; GET, HEAD, Bereichs-GET und mehrteiliger Upload geprüft. +- **Nach dem Rebalancing:** kein Speicherpool aktiv oder stoppend; `lastError` leer oder erklärt; `cleanupWarnings` behandelt; Stopp-Weitergabe abgeschlossen; migrierte Objekte lesbar. +- **Nach der Außerbetriebnahme:** Status `completed`; andere Einträge gemäß Richtlinie behandelt; der Quellpool lehnt neue Schreibvorgänge ab; freie Versionen, Tier-Zugehörigkeit und Auflistungseinträge sind zusammengeführt; Startargumente auf jedem Knoten aktualisiert, bevor Laufwerke getrennt werden. +- **Nach Datenwiederherstellung oder Austausch:** Ersatzwiederherstellung `completed`; Slot und UUID korrekt; Heal-Warteschlange geleert; keine wachsende Bitrot-Zahl; stichprobenartig geprüfte aktuelle und historische Versionen lesbar; keine übrig gebliebenen temporären Verzeichnisse. -## rc command mapping +## Zuordnung der rc-Befehle -`rc` is the RustFS CLI (see [CLI Client (rc)](./rc.mdx)); its `expand` group is an alias of `rebalance` — there is no server-side expand API. Flags below are the commonly used ones; check `rc admin --help` for the installed version. +`rc` ist die RustFS-CLI (siehe [CLI-Client (rc)](./rc.mdx)). Die Gruppe `expand` ist ein Alias von `rebalance`. Eine serverseitige Expand-API gibt es nicht. Die folgenden Optionen sind die häufig verwendeten. Prüfen Sie `rc admin --help` für die installierte Version. ```bash rc alias set local http://localhost:9000 @@ -261,18 +261,18 @@ rc admin heal status local --client-token rc admin heal stop local --client-token ``` -| `rc` command | Server route | +| `rc`-Befehl | Serverroute | |---|---| | `rc ping` / `rc ready` | `GET /health` / `GET /health/ready` | | `rc admin pool list` / `status` | `GET /rustfs/admin/v3/pools/list` / `GET /rustfs/admin/v3/pools/status` | -| `rc admin rebalance …` (alias `expand`) | `/rustfs/admin/v3/rebalance/*` | +| `rc admin rebalance …` (Alias `expand`) | `/rustfs/admin/v3/rebalance/*` | | `rc admin decommission start` / `cancel` / `clear` | `POST /rustfs/admin/v3/pools/decommission` / `cancel` / `clear` | | `rc admin decommission status` | `GET /rustfs/admin/v3/decommission/status` | | `rc admin heal start` / `status` / `stop` | `/rustfs/admin/v3/heal/*`, `POST /rustfs/admin/v3/background-heal/status` | -`rc admin heal start` exposes `--bucket`, `--prefix`, `--scan-mode`, `--remove`, `--recreate`, and `--dry-run`; it does not expose `nolock`, `forceStart`, `forceStop`, `pool`, or `set`. There is no `rc` command for replacement recovery; call `GET /rustfs/admin/v4/heal/replacement-recovery` directly. +`rc admin heal start` stellt `--bucket`, `--prefix`, `--scan-mode`, `--remove`, `--recreate` und `--dry-run` bereit. `nolock`, `forceStart`, `forceStop`, `pool` und `set` stellt es nicht bereit. Für die Ersatzwiederherstellung gibt es keinen `rc`-Befehl. Rufen Sie `GET /rustfs/admin/v4/heal/replacement-recovery` direkt auf. -## References +## Referenzen -- Upstream runbook: `docs/operations/cluster-lifecycle-operations.md` in [rustfs/rustfs#7998](https://github.com/rustfs/rustfs/pull/7998) — the source this page is adapted from, verified claim by claim against the RustFS source code. -- [Storage Pool Expansion](./scaling/storage-pool-expansion.md) · [Data Rebalancing](./scaling/data-rebalancing.md) · [Storage Pool Decommission](./scaling/storage-pool-decommission.md) · [Node Healing](./high-availability/node-healing.md) · [CLI Client (rc)](./rc.mdx) +- Upstream-Runbook: `docs/operations/cluster-lifecycle-operations.md` in [rustfs/rustfs#7998](https://github.com/rustfs/rustfs/pull/7998). Daraus ist diese Seite abgeleitet und Aussage für Aussage gegen den RustFS-Quellcode geprüft. +- [Speicherpool-Erweiterung](./scaling/storage-pool-expansion.md) · [Daten-Rebalancing](./scaling/data-rebalancing.md) · [Speicherpool-Außerbetriebnahme](./scaling/storage-pool-decommission.md) · [Datenwiederherstellung von Knoten](./high-availability/node-healing.md) · [CLI-Client (rc)](./rc.mdx) diff --git a/content/de/operations/credentials.md b/content/de/operations/credentials.md index 91c4500e7..c33c02fb8 100644 --- a/content/de/operations/credentials.md +++ b/content/de/operations/credentials.md @@ -1,46 +1,46 @@ --- -title: "Credential Management" -description: "This article covers configuring RustFS root credentials via environment variables and secret files, rotating them safely, the internode RPC secret, and the MinIO-compatible environment aliases." +title: "Anmeldedatenverwaltung" +description: "Konfigurieren und rotieren Sie die Root-Anmeldedaten von RustFS, legen Sie das RPC-Geheimnis zwischen den Knoten fest und nutzen Sie MinIO-kompatible Umgebungsaliase." --- -## Root Credentials +## Root-Anmeldedaten -RustFS reads its root (admin) credential pair from: +RustFS liest sein Root-Paar (Admin) aus: ```bash RUSTFS_ACCESS_KEY= RUSTFS_SECRET_KEY= ``` -If neither is provided, the server falls back to the built-in default `rustfsadmin` / `rustfsadmin`. +Wenn keines von beiden gesetzt ist, fällt der Server auf den eingebauten Standard `rustfsadmin` / `rustfsadmin` zurück. -:::warning[Choose safe root credentials] +:::warning[Sichere Root-Anmeldedaten wählen] -[AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-signing-elements.html) embeds the access key in a slash-delimited credential scope: +[AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-signing-elements.html) bettet den Zugriffsschlüssel in einen durch Schrägstriche getrennten Gültigkeitsbereich der Anmeldedaten ein: `////aws4_request` -Do not include `/` in `RUSTFS_ACCESS_KEY`, because it causes the access key and credential scope to be parsed incorrectly. We recommend using only uppercase ASCII letters and digits (`A-Z`, `0-9`), matching the format generated by RustFS. Do not use unmodified Base64 output as an access key; use a separate strong random value for `RUSTFS_SECRET_KEY`. +Nehmen Sie kein `/` in `RUSTFS_ACCESS_KEY` auf, weil Zugriffsschlüssel und Gültigkeitsbereich sonst falsch zerlegt werden. Wir empfehlen, nur ASCII-Großbuchstaben und Ziffern (`A-Z`, `0-9`) zu verwenden, passend zum Format, das RustFS erzeugt. Verwenden Sie unveränderte Base64-Ausgabe nicht als Zugriffsschlüssel. Verwenden Sie für `RUSTFS_SECRET_KEY` einen eigenen starken Zufallswert. -The default `rustfsadmin` credentials are public and well-known. The container entrypoint prints a warning but still starts. Always set non-default credentials before exposing ports 9000/9001 beyond localhost. Additionally, a multi-node cluster running with an all-default pair **must** set `RUSTFS_RPC_SECRET` (see below) — the server refuses to derive internode RPC auth from the default secret key. +Die Standard-Anmeldedaten `rustfsadmin` sind öffentlich und allgemein bekannt. Der Einstiegspunkt des Containers gibt eine Warnung aus, startet aber trotzdem. Setzen Sie immer von den Standardwerten abweichende Anmeldedaten, bevor Sie die Ports 9000 und 9001 über localhost hinaus freigeben. Zusätzlich **muss** ein Cluster mit mehreren Knoten, der mit einem Paar aus lauter Standardwerten läuft, `RUSTFS_RPC_SECRET` setzen (siehe unten). Der Server lehnt es ab, die RPC-Authentifizierung zwischen den Knoten aus dem standardmäßigen geheimen Zugriffsschlüssel abzuleiten. ::: -## File-Based Injection (Docker/Kubernetes Secrets) +## Übergabe über Dateien (Docker- und Kubernetes-Secrets) -Instead of putting secrets into the environment, point RustFS at files containing them: +Statt Geheimnisse in die Umgebung zu legen, verweisen Sie RustFS auf Dateien, die sie enthalten: ```bash RUSTFS_ACCESS_KEY_FILE=/run/secrets/rustfs_access_key RUSTFS_SECRET_KEY_FILE=/run/secrets/rustfs_secret_key ``` -Equivalent CLI flags exist (`--access-key-file`, `--secret-key-file`). Rules enforced by the container entrypoint: +Es gibt gleichwertige CLI-Optionen (`--access-key-file`, `--secret-key-file`). Der Einstiegspunkt des Containers erzwingt diese Regeln: -- Only the **first line** of the file is read; surrounding whitespace and CR characters (CRLF-edited files) are trimmed. A file without a trailing newline is valid. -- Setting both the direct variable and the `_FILE` variant for the same credential is a hard error: `Set either RUSTFS_ACCESS_KEY or RUSTFS_ACCESS_KEY_FILE, not both.` -- An empty value, an empty file, or an unreadable file is a hard error (exit 1). -- A file containing the default `rustfsadmin` value triggers the same warning as the direct variable. +- Gelesen wird nur die **erste Zeile** der Datei. Umgebender Leerraum und CR-Zeichen (mit CRLF bearbeitete Dateien) werden abgeschnitten. Eine Datei ohne abschließenden Zeilenumbruch ist gültig. +- Beide Varianten für dieselbe Anmeldedatenart zu setzen, die direkte Variable und die Variante `_FILE`, ist ein harter Fehler: `Set either RUSTFS_ACCESS_KEY or RUSTFS_ACCESS_KEY_FILE, not both.` +- Ein leerer Wert, eine leere Datei oder eine nicht lesbare Datei ist ein harter Fehler (Exit 1). +- Eine Datei mit dem Standardwert `rustfsadmin` löst dieselbe Warnung aus wie die direkte Variable. ```yaml title="docker-compose example with secrets" services: @@ -59,60 +59,60 @@ secrets: file: ./secrets/secret_key.txt ``` -## Rotating the Root Credentials +## Root-Anmeldedaten rotieren -All nodes of a cluster must run with the **same** root credential pair — internode RPC authentication is derived from it unless `RUSTFS_RPC_SECRET` is set explicitly. +Alle Knoten eines Clusters müssen mit **demselben** Paar der Root-Anmeldedaten laufen. Die RPC-Authentifizierung zwischen den Knoten wird daraus abgeleitet, sofern `RUSTFS_RPC_SECRET` nicht ausdrücklich gesetzt ist. :::note -The step-by-step procedure below is standard operational practice composed from verified building blocks (env/file configuration plus the verified rolling-restart readiness signals); RustFS does not currently document an online root-credential rotation API. +Das folgende schrittweise Vorgehen entspricht der üblichen Betriebspraxis und setzt sich aus geprüften Bausteinen zusammen (Konfiguration über Umgebung oder Datei sowie die geprüften Bereitschaftssignale beim rollierenden Neustart). RustFS dokumentiert derzeit keine API für die Online-Rotation der Root-Anmeldedaten. ::: -1. If you have not already, set an explicit `RUSTFS_RPC_SECRET` (same value on all nodes) **before** the rotation. This decouples internode auth from the credential pair, so the cluster tolerates nodes temporarily running with mixed old/new root credentials during the rolling restart. -2. Update the environment file / secret on **every** node with the new `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` (or the files behind the `_FILE` variants). -3. Restart nodes **one at a time**, waiting for each to return `200` from `GET /health/ready` on port 9000 before restarting the next. -4. Update every client, SDK configuration, and automation that used the old pair. -5. Verify: sign a request with the old credentials and confirm it is rejected. +1. Setzen Sie, falls noch nicht geschehen, ein ausdrückliches `RUSTFS_RPC_SECRET` (derselbe Wert auf allen Knoten) **vor** der Rotation. Dadurch wird die Authentifizierung zwischen den Knoten vom Anmeldedatenpaar entkoppelt, und der Cluster toleriert während des rollierenden Neustarts Knoten, die vorübergehend mit gemischten alten und neuen Root-Anmeldedaten laufen. +2. Aktualisieren Sie die Umgebungsdatei oder das Secret auf **jedem** Knoten mit dem neuen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` (oder den Dateien hinter den Varianten `_FILE`). +3. Starten Sie die Knoten **einzeln** neu und warten Sie, bis jeder auf Port 9000 von `GET /health/ready` den Status `200` liefert, bevor Sie den nächsten neu starten. +4. Aktualisieren Sie jeden Client, jede SDK-Konfiguration und jede Automatisierung, die das alte Paar verwendet hat. +5. Prüfen Sie: Signieren Sie eine Anfrage mit den alten Anmeldedaten und bestätigen Sie, dass sie abgelehnt wird. -## RUSTFS_RPC_SECRET (Internode RPC Auth) +## RUSTFS_RPC_SECRET (RPC-Authentifizierung zwischen den Knoten) -Nodes of a distributed cluster authenticate their internal RPC traffic with a shared secret: +Die Knoten eines verteilten Clusters authentifizieren ihren internen RPC-Verkehr mit einem gemeinsamen Geheimnis: -- If `RUSTFS_RPC_SECRET` is set, that value is used directly. Set the **same value on every node**. -- If it is unset, the secret is **derived** (HMAC) from the active access/secret key pair — which is why all nodes must share the same root credentials. -- Derivation **fails closed** when the secret key is the default `rustfsadmin`: a publicly known secret would yield a publicly computable RPC secret that any network peer could use to forge internode signatures. In that configuration internode RPC cannot authenticate until you either set `RUSTFS_RPC_SECRET` or configure a non-default `RUSTFS_SECRET_KEY`. +- Wenn `RUSTFS_RPC_SECRET` gesetzt ist, wird dieser Wert direkt verwendet. Setzen Sie **auf jedem Knoten denselben Wert**. +- Wenn es nicht gesetzt ist, wird das Geheimnis per HMAC aus dem aktiven Paar von Zugriffsschlüssel und geheimem Zugriffsschlüssel **abgeleitet**. Deshalb müssen alle Knoten dieselben Root-Anmeldedaten verwenden. +- Die Ableitung **verweigert die Authentifizierung**, wenn der geheime Zugriffsschlüssel der Standardwert `rustfsadmin` ist: Ein öffentlich bekanntes Geheimnis würde ein öffentlich berechenbares RPC-Geheimnis ergeben, mit dem jeder Netz-Peer Signaturen zwischen den Knoten fälschen könnte. In dieser Konfiguration kann die RPC zwischen den Knoten sich nicht authentifizieren, bis Sie entweder `RUSTFS_RPC_SECRET` setzen oder einen vom Standard abweichenden `RUSTFS_SECRET_KEY` konfigurieren. -When to set it explicitly: +Wann Sie es ausdrücklich setzen: -- multi-node clusters that (temporarily or otherwise) run with default root credentials; -- before rotating root credentials, to keep internode auth stable during the rollout; -- environments where you want internode auth independent of the S3 root credential lifecycle. +- Cluster mit mehreren Knoten, die (vorübergehend oder dauerhaft) mit standardmäßigen Root-Anmeldedaten laufen; +- vor der Rotation der Root-Anmeldedaten, damit die Authentifizierung zwischen den Knoten während der Ausrollung stabil bleibt; +- Umgebungen, in denen die Authentifizierung zwischen den Knoten unabhängig vom Lebenszyklus der S3-Root-Anmeldedaten sein soll. ```bash # Same value on every node RUSTFS_RPC_SECRET= ``` -## Compatibility Aliases +## Kompatibilitätsaliase -For drop-in migration, RustFS accepts credential variables under legacy and MinIO-compatible names when the canonical `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` are not set: +Für die Migration bestehender Umgebungen akzeptiert RustFS Variablen für Zugangsdaten unter älteren und MinIO-kompatiblen Namen, wenn die kanonischen Namen `RUSTFS_ACCESS_KEY` und `RUSTFS_SECRET_KEY` nicht gesetzt sind: -| Accepted alias | Canonical variable | +| Akzeptierter Alias | Kanonische Variable | | --- | --- | -| `RUSTFS_ROOT_USER` (legacy) | `RUSTFS_ACCESS_KEY` | -| `RUSTFS_ROOT_PASSWORD` (legacy) | `RUSTFS_SECRET_KEY` | +| `RUSTFS_ROOT_USER` (älter) | `RUSTFS_ACCESS_KEY` | +| `RUSTFS_ROOT_PASSWORD` (älter) | `RUSTFS_SECRET_KEY` | | `MINIO_ROOT_USER` | `RUSTFS_ROOT_USER` → `RUSTFS_ACCESS_KEY` | | `MINIO_ROOT_PASSWORD` | `RUSTFS_ROOT_PASSWORD` → `RUSTFS_SECRET_KEY` | -The `MINIO_` prefix mapping covers a broader allowlist of variables (address, console address, audit webhook settings, and more), applied at startup as "external-prefix compatibility mappings". +Die Zuordnung des Präfixes `MINIO_` umfasst eine breitere Zulassungsliste von Variablen (Adresse, Console-Adresse, Einstellungen für Audit-Webhooks und weitere). Sie wird beim Start als Kompatibilitätszuordnung für externe Präfixe angewendet. :::note -Aliases are deprecated. When one is used, the server logs a one-time warning of the form `Environment variable MINIO_ROOT_USER is deprecated, use RUSTFS_ROOT_USER instead`. Use the `RUSTFS_`-prefixed canonical names in new deployments; the canonical name always wins when both are set. +Aliase sind veraltet. Wird einer verwendet, protokolliert der Server einmalig eine Warnung der Form `Environment variable MINIO_ROOT_USER is deprecated, use RUSTFS_ROOT_USER instead`. Verwenden Sie in neuen Bereitstellungen die kanonischen Namen mit dem Präfix `RUSTFS_`. Der kanonische Name gewinnt immer, wenn beide gesetzt sind. ::: -## Beyond the Root Credential +## Über die Root-Anmeldedaten hinaus -Day-to-day access should not use the root pair. Create scoped users, groups, policies, and service accounts through the console on port 9001 or the IAM admin APIs, and reserve the root credential for administrative operations. See the IAM documentation in the administration section. +Der tägliche Zugriff sollte nicht das Root-Paar verwenden. Legen Sie eingeschränkte Benutzer, Gruppen, Richtlinien und Servicekonten über die Console auf Port 9001 oder die IAM-Admin-APIs an und behalten Sie die Root-Anmeldedaten administrativen Vorgängen vor. Siehe die IAM-Dokumentation im Abschnitt Verwaltung. diff --git a/content/de/operations/event-notifications.md b/content/de/operations/event-notifications.md index a6162a4f4..afc68d157 100644 --- a/content/de/operations/event-notifications.md +++ b/content/de/operations/event-notifications.md @@ -1,36 +1,36 @@ --- -title: "Event Notifications" -description: "Configure RustFS bucket event notifications and deliver filtered object events to external targets." +title: "Ereignisbenachrichtigungen" +description: "Konfigurieren Sie Bucket-Ereignisbenachrichtigungen in RustFS und liefern Sie gefilterte Objektereignisse an externe Ziele." --- -RustFS Event Notifications deliver S3 bucket activity to external systems. This guide configures a webhook target, associates it with a bucket, and verifies delivery with AWS CLI. +RustFS-Ereignisbenachrichtigungen liefern S3-Bucket-Aktivität an externe Systeme. In dieser Anleitung konfigurieren Sie ein Webhook-Ziel, ordnen es einem Bucket zu und prüfen die Zustellung mit der AWS CLI. -## Overview +## Überblick -An event notification has two independent parts: +Eine Ereignisbenachrichtigung hat zwei unabhängige Teile: -- A **notification target** defines where RustFS sends events. -- A **bucket notification configuration** selects the target, event types, and optional object-key filters for one bucket. +- Ein **Benachrichtigungsziel** legt fest, wohin RustFS Ereignisse sendet. +- Eine **Bucket-Benachrichtigungskonfiguration** wählt das Ziel, die Ereignistypen und optionale Filter für Objektschlüssel für einen Bucket. -RustFS supports webhook, Kafka, MQTT, MySQL, PostgreSQL, NATS, Redis, AMQP, and Pulsar target families. The webhook workflow below is useful for HTTP services, serverless functions, and integration platforms. +RustFS unterstützt die Zielfamilien Webhook, Kafka, MQTT, MySQL, PostgreSQL, NATS, Redis, AMQP und Pulsar. Der folgende Webhook-Ablauf eignet sich für HTTP-Dienste, serverlose Funktionen und Integrationsplattformen. -Bucket rules use the S3 `PutBucketNotificationConfiguration` and `GetBucketNotificationConfiguration` APIs. RustFS currently accepts queue configurations; AWS SNS topic and Lambda function configurations are not supported. +Bucket-Regeln verwenden die S3-APIs `PutBucketNotificationConfiguration` und `GetBucketNotificationConfiguration`. RustFS akzeptiert derzeit Warteschlangenkonfigurationen. Konfigurationen für AWS-SNS-Themen und Lambda-Funktionen werden nicht unterstützt. -Common event families include: +Übliche Ereignisfamilien sind: -| Event family | Example events | +| Ereignisfamilie | Beispielereignisse | | --- | --- | -| Object creation | `s3:ObjectCreated:Put`, `s3:ObjectCreated:Copy`, `s3:ObjectCreated:CompleteMultipartUpload` | -| Object removal | `s3:ObjectRemoved:Delete`, `s3:ObjectRemoved:DeleteMarkerCreated` | -| Object access | `s3:ObjectAccessed:Get`, `s3:ObjectAccessed:Head` | -| Object tagging | `s3:ObjectTagging:Put`, `s3:ObjectTagging:Delete` | -| Lifecycle and tiering | Expiration, restore, replication, and transition events | +| Objekterstellung | `s3:ObjectCreated:Put`, `s3:ObjectCreated:Copy`, `s3:ObjectCreated:CompleteMultipartUpload` | +| Objektentfernung | `s3:ObjectRemoved:Delete`, `s3:ObjectRemoved:DeleteMarkerCreated` | +| Objektzugriff | `s3:ObjectAccessed:Get`, `s3:ObjectAccessed:Head` | +| Objekt-Tagging | `s3:ObjectTagging:Put`, `s3:ObjectTagging:Delete` | +| Lebenszyklus und Stufung | Ereignisse für Ablauf, Wiederherstellung, Replikation und Übergang | -Use a wildcard such as `s3:ObjectCreated:*` to subscribe to every event in a family. +Verwenden Sie einen Platzhalter wie `s3:ObjectCreated:*`, um jedes Ereignis einer Familie zu abonnieren. -## Configuration +## Konfiguration -Event Notifications are disabled by default. The following environment variables enable the module and create a webhook target named `primary`: +Ereignisbenachrichtigungen sind standardmäßig deaktiviert. Die folgenden Umgebungsvariablen aktivieren das Modul und legen ein Webhook-Ziel namens `primary` an: ```bash export RUSTFS_NOTIFY_ENABLE="true" @@ -41,40 +41,40 @@ export RUSTFS_NOTIFY_WEBHOOK_QUEUE_DIR_PRIMARY="/var/lib/rustfs/notify-primary" export RUSTFS_OUTBOUND_ALLOW_ORIGINS="https://events.example.com" ``` -Restart RustFS after changing environment-managed targets. The target name is the lowercase form of the environment-variable suffix, so `_PRIMARY` creates `primary`. Use the target ARN `arn:rustfs:sqs:us-east-1:primary:webhook` in the bucket configuration. +Starten Sie RustFS neu, nachdem Sie Ziele geändert haben, die über die Umgebung verwaltet werden. Der Zielname ist die Kleinschreibung des Suffixes der Umgebungsvariablen. `_PRIMARY` erzeugt also `primary`. Verwenden Sie in der Bucket-Konfiguration den Ziel-ARN `arn:rustfs:sqs:us-east-1:primary:webhook`. -RustFS sends a `HEAD` health check to the endpoint origin's root path, such as `https://events.example.com/`, and sends JSON `POST` requests to the complete configured endpoint. The origin must respond to `HEAD`, while delivery requests must return a successful HTTP status. Allow the RustFS service account to write to the queue directory. +RustFS sendet eine `HEAD`-Integritätsprüfung an den Wurzelpfad des Endpunkt-Ursprungs, etwa `https://events.example.com/`, und sendet JSON-`POST`-Anfragen an den vollständig konfigurierten Endpunkt. Der Ursprung muss auf `HEAD` antworten, und Zustellanfragen müssen einen erfolgreichen HTTP-Status liefern. Erlauben Sie dem RustFS-Dienstkonto, in das Warteschlangenverzeichnis zu schreiben. -### Webhook settings +### Webhook-Einstellungen -Use the same `_PRIMARY` suffix on all settings for this target: +Verwenden Sie für alle Einstellungen dieses Ziels dasselbe Suffix `_PRIMARY`: -| Variable | Purpose | +| Variable | Zweck | | --- | --- | -| `RUSTFS_NOTIFY_WEBHOOK_ENDPOINT_PRIMARY` | HTTP or HTTPS delivery endpoint | -| `RUSTFS_NOTIFY_WEBHOOK_AUTH_TOKEN_PRIMARY` | Bearer token sent in the `Authorization` header | -| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_DIR_PRIMARY` | Directory for queued deliveries | -| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_LIMIT_PRIMARY` | Maximum number of queued events | -| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CERT_PRIMARY` | Client certificate for mutual TLS (mTLS) | -| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_KEY_PRIMARY` | Private key paired with the client certificate | -| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CA_PRIMARY` | Certificate authority used to verify the receiver | -| `RUSTFS_NOTIFY_WEBHOOK_SKIP_TLS_VERIFY_PRIMARY` | Disable server certificate verification | +| `RUSTFS_NOTIFY_WEBHOOK_ENDPOINT_PRIMARY` | HTTP- oder HTTPS-Zustellendpunkt | +| `RUSTFS_NOTIFY_WEBHOOK_AUTH_TOKEN_PRIMARY` | Bearer-Token, das im Header `Authorization` gesendet wird | +| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_DIR_PRIMARY` | Verzeichnis für eingereihte Zustellungen | +| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_LIMIT_PRIMARY` | Höchstzahl eingereihter Ereignisse | +| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CERT_PRIMARY` | Client-Zertifikat für gegenseitiges TLS (mTLS) | +| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_KEY_PRIMARY` | Privater Schlüssel zum Client-Zertifikat | +| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CA_PRIMARY` | Zertifizierungsstelle, mit der der Empfänger geprüft wird | +| `RUSTFS_NOTIFY_WEBHOOK_SKIP_TLS_VERIFY_PRIMARY` | Prüfung des Serverzertifikats deaktivieren | -:::warning[Keep certificate verification enabled] +:::warning[Zertifikatsprüfung aktiviert lassen] -Do not enable `RUSTFS_NOTIFY_WEBHOOK_SKIP_TLS_VERIFY_PRIMARY` in production. Configure `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CA_PRIMARY` when the receiver uses a private certificate authority. If you use mTLS, provide both the client certificate and private key. +Aktivieren Sie `RUSTFS_NOTIFY_WEBHOOK_SKIP_TLS_VERIFY_PRIMARY` in der Produktion nicht. Konfigurieren Sie `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CA_PRIMARY`, wenn der Empfänger eine private Zertifizierungsstelle verwendet. Wenn Sie mTLS verwenden, geben Sie sowohl das Client-Zertifikat als auch den privaten Schlüssel an. ::: -For all target families and target-specific keys, see [Environment Variables](/reference/environment-variables#event--audit-targets). +Alle Zielfamilien und zielspezifischen Schlüssel stehen unter [Umgebungsvariablen](/de/reference/environment-variables#event--audit-targets). -## Usage +## Verwendung -The following example sends creation and removal events for `.dat` objects under `uploads/` to the `primary` webhook. +Das folgende Beispiel sendet Erstellungs- und Entfernungsereignisse für `.dat`-Objekte unter `uploads/` an den Webhook `primary`. -### Configure the bucket rule +### Bucket-Regel konfigurieren -Create the notification configuration: +Legen Sie die Benachrichtigungskonfiguration an: ```json title="notification.json" { @@ -99,7 +99,7 @@ Create the notification configuration: } ``` -Apply it to `my-bucket` with [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html): +Wenden Sie sie mit der [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) auf `my-bucket` an: ```bash aws --endpoint-url http://localhost:9000 \ @@ -109,9 +109,9 @@ aws --endpoint-url http://localhost:9000 \ --notification-configuration file://notification.json ``` -Saving a bucket rule does not prove that its target exists or is online. Confirm that the module and target are enabled, the receiver answers health checks, and a test object operation produces a delivery. +Das Speichern einer Bucket-Regel belegt nicht, dass ihr Ziel existiert oder online ist. Bestätigen Sie, dass Modul und Ziel aktiviert sind, der Empfänger auf Integritätsprüfungen antwortet und eine Testoperation an einem Objekt eine Zustellung erzeugt. -Read the active configuration: +Lesen Sie die aktive Konfiguration: ```bash aws --endpoint-url http://localhost:9000 \ @@ -120,13 +120,13 @@ aws --endpoint-url http://localhost:9000 \ --bucket my-bucket ``` -Prefix and suffix filters are case-sensitive and are combined with AND logic. A rule can contain at most one prefix and one suffix filter. +Präfix- und Suffixfilter unterscheiden Groß- und Kleinschreibung und werden mit UND-Logik kombiniert. Eine Regel kann höchstens einen Präfix- und einen Suffixfilter enthalten. -### Manage rules with rc +### Regeln mit rc verwalten -The `rc` client can add, list, and remove bucket notification rules. It does not configure the notification module or create the underlying webhook, broker, or database target; configure those first through environment variables or the Console. +Der Client `rc` kann Bucket-Benachrichtigungsregeln hinzufügen, auflisten und entfernen. Er konfiguriert das Benachrichtigungsmodul nicht und legt das zugrunde liegende Webhook-, Broker- oder Datenbankziel nicht an. Konfigurieren Sie diese zuerst über Umgebungsvariablen oder die Console. -Add creation and removal events for the `primary` target: +Fügen Sie Erstellungs- und Entfernungsereignisse für das Ziel `primary` hinzu: ```bash rc bucket event add \ @@ -135,13 +135,13 @@ rc bucket event add \ --event put,delete ``` -List the active rules: +Listen Sie die aktiven Regeln auf: ```bash rc --json bucket event list rustfs/my-bucket ``` -Remove every rule associated with that target ARN: +Entfernen Sie jede Regel, die mit diesem Ziel-ARN verknüpft ist: ```bash rc bucket event remove \ @@ -149,11 +149,11 @@ rc bucket event remove \ arn:rustfs:sqs:us-east-1:primary:webhook ``` -The current `rc bucket event add` command does not expose prefix or suffix filter options. Use AWS CLI when the rule must filter object keys. +Der aktuelle Befehl `rc bucket event add` stellt keine Optionen für Präfix- oder Suffixfilter bereit. Verwenden Sie die AWS CLI, wenn die Regel Objektschlüssel filtern muss. -### Trigger and inspect events +### Ereignisse auslösen und prüfen -Upload and remove a matching object: +Laden Sie ein passendes Objekt hoch und entfernen Sie es: ```bash printf 'hello from RustFS\n' > hello.txt @@ -167,7 +167,7 @@ aws --endpoint-url http://localhost:9000 \ s3 rm s3://my-bucket/uploads/hello.dat ``` -The webhook receives an S3-compatible JSON envelope. Important fields include the event name, bucket, object key, size, ETag, and request identifiers: +Der Webhook empfängt eine S3-kompatible JSON-Hülle. Wichtige Felder sind der Ereignisname, der Bucket, der Objektschlüssel, die Größe, das ETag und die Anfragekennungen: ```json { @@ -184,13 +184,13 @@ The webhook receives an S3-compatible JSON envelope. Important fields include th } ``` -Decode the object key as URL-encoded data before using it. Consumers should also be idempotent: queued delivery provides store-and-forward recovery, but a receiver can observe the same event more than once. +Decodieren Sie den Objektschlüssel als URL-codierte Daten, bevor Sie ihn verwenden. Verbraucher sollten außerdem idempotent sein: Die eingereihte Zustellung kann Ereignisse zwischenspeichern und später weiterleiten, ein Empfänger kann dasselbe Ereignis aber mehr als einmal sehen. -### Replace or remove rules +### Regeln ersetzen oder entfernen -`PutBucketNotificationConfiguration` replaces the complete notification configuration for the bucket. Include every rule that you want to retain when updating it. +`PutBucketNotificationConfiguration` ersetzt die vollständige Benachrichtigungskonfiguration des Buckets. Nehmen Sie beim Aktualisieren jede Regel auf, die Sie behalten wollen. -Remove all rules by applying an empty configuration: +Entfernen Sie alle Regeln, indem Sie eine leere Konfiguration anwenden: ```bash aws --endpoint-url http://localhost:9000 \ @@ -200,6 +200,6 @@ aws --endpoint-url http://localhost:9000 \ --notification-configuration '{}' ``` -## Next steps +## Nächste Schritte -Configure [Audit Targets](/security-compliance/audit-logs) when you need request-level security and compliance records instead of bucket-scoped object events. Review [Observability](/operations/observability) to monitor the RustFS service. \ No newline at end of file +Konfigurieren Sie [Audit-Ziele](/de/security-compliance/audit-logs), wenn Sie Sicherheits- und Compliance-Nachweise auf Anfrageebene brauchen statt bucketbezogener Objektereignisse. Lesen Sie [Observability](/de/operations/observability), um den RustFS-Dienst zu überwachen. diff --git a/content/de/operations/high-availability/index.md b/content/de/operations/high-availability/index.md index d274c255a..313e26c0d 100644 --- a/content/de/operations/high-availability/index.md +++ b/content/de/operations/high-availability/index.md @@ -1,7 +1,7 @@ --- -title: "High Availability" -description: "Review RustFS site replication and node recovery guidance." +title: "Hochverfügbarkeit" +description: "Lesen Sie die Hinweise zur Site-Replikation und zur Datenwiederherstellung von Knoten in RustFS." --- -- [Site Replication](./site-replication.md) -- [Node Healing](./node-healing.md) \ No newline at end of file +- [Site-Replikation](./site-replication.md) +- [Datenwiederherstellung von Knoten](./node-healing.md) diff --git a/content/de/operations/high-availability/node-healing.md b/content/de/operations/high-availability/node-healing.md index ef7bbd8f9..4a6b84af3 100644 --- a/content/de/operations/high-availability/node-healing.md +++ b/content/de/operations/high-availability/node-healing.md @@ -1,52 +1,52 @@ --- -title: "Node Healing" -description: "Recover failed RustFS nodes and disks, monitor automatic healing, and run bounded manual heal tasks with rc." +title: "Datenwiederherstellung von Knoten" +description: "Stellen Sie ausgefallene RustFS-Knoten und Laufwerke wieder her, überwachen Sie die automatische Datenwiederherstellung und führen Sie begrenzte manuelle Heal-Aufgaben mit rc aus." --- -RustFS healing reconstructs missing or inconsistent erasure-coded data from the healthy shards that remain in a storage set. Use this workflow after restoring an unavailable node, replacing a failed disk, or investigating scanner and heal alerts. +Die Datenwiederherstellung (Healing) von RustFS rekonstruiert fehlende oder inkonsistente Daten mit Erasure Coding aus den gesunden Shards, die in einem Speicherset verbleiben. Verwenden Sie diesen Ablauf, nachdem Sie einen nicht verfügbaren Knoten wiederhergestellt, ein ausgefallenes Laufwerk ersetzt oder Alarme des Scanners und der Datenwiederherstellung geprüft haben. -Healing is a cluster storage operation. It is different from [site replication](/operations/high-availability/site-replication), which copies data and identity configuration between independent RustFS deployments. +Die Datenwiederherstellung ist ein Speichervorgang des Clusters. Sie unterscheidet sich von der [Site-Replikation](/de/operations/high-availability/site-replication), die Daten und Identitätskonfiguration zwischen unabhängigen RustFS-Bereitstellungen kopiert. -:::warning[Healing is not a backup] +:::warning[Datenwiederherstellung ist keine Sicherung] -RustFS can reconstruct data only while enough healthy shards remain in the affected erasure set. Healing cannot recover an object after failures exceed the set's available redundancy, and it does not protect against intentional deletion or application-level corruption. Maintain independent backups or replication according to your recovery requirements. +RustFS kann Daten nur rekonstruieren, solange im betroffenen Erasure-Set genug gesunde Shards verbleiben. Die Datenwiederherstellung kann ein Objekt nicht wiederherstellen, wenn die Ausfälle die verfügbare Redundanz des Sets überschreiten, und sie schützt nicht vor absichtlichem Löschen oder vor Beschädigung auf Anwendungsebene. Halten Sie unabhängige Sicherungen oder Replikation gemäß Ihren Wiederherstellungsanforderungen vor. ::: -## How healing works +## Wie die Datenwiederherstellung arbeitet -RustFS coordinates several healing sources through the cluster heal queue: +RustFS koordiniert mehrere Quellen der Datenwiederherstellung über die Heal-Warteschlange des Clusters: -- `autoHeal`: The automatic disk scanner detects disks that are unformatted or have returned after an outage and queues erasure-set healing. -- `scanner`: The background data scanner can queue object and bucket healing when it finds inconsistent storage state. -- `readRepair`: Read-repair paths can submit work discovered while serving requests. -- `internal`: Internal recovery paths can submit system-initiated work. -- `admin`: Administrators can submit a recursive, bucket, or prefix heal with `rc admin heal start`. +- `autoHeal`: Der automatische Laufwerksscanner erkennt Laufwerke, die unformatiert sind oder nach einem Ausfall zurückgekehrt sind, und reiht die Datenwiederherstellung des Erasure-Sets ein. +- `scanner`: Der Hintergrundscanner der Daten kann die Datenwiederherstellung von Objekten und Buckets einreihen, wenn er einen inkonsistenten Speicherzustand findet. +- `readRepair`: Pfade der Lesereparatur können Arbeit einreichen, die beim Bedienen von Anfragen entdeckt wurde. +- `internal`: Interne Wiederherstellungspfade können vom System angestoßene Arbeit einreichen. +- `admin`: Administratoren können mit `rc admin heal start` eine rekursive Datenwiederherstellung, eine für einen Bucket oder eine für ein Präfix einreichen. -Automatic disk healing runs at low priority. The `healOperations` status object uses these source names to separate queued, active, and retrying work. +Die automatische Datenwiederherstellung von Laufwerken läuft mit niedriger Priorität. Das Statusobjekt `healOperations` verwendet diese Quellnamen, um eingereihte, aktive und erneut versuchte Arbeit zu trennen. -:::note[Reconstruction consumes cluster resources] +:::note[Die Rekonstruktion verbraucht Clusterressourcen] -Healing reads healthy shards and writes reconstructed data. Deep scans add read and checksum work. Monitor client latency, disk utilization, available capacity, and the heal queue while recovery is active. +Die Datenwiederherstellung liest gesunde Shards und schreibt rekonstruierte Daten. Tiefe Scans fügen Lese- und Prüfsummenarbeit hinzu. Beobachten Sie die Client-Latenz, die Laufwerksauslastung, die verfügbare Kapazität und die Heal-Warteschlange, solange die Wiederherstellung aktiv ist. ::: -## Requirements +## Voraussetzungen -Before recovering a node or disk, prepare: +Bereiten Sie vor der Wiederherstellung eines Knotens oder Laufwerks Folgendes vor: -- A RustFS deployment that still has enough healthy shards to reconstruct the affected data. -- Stable node addresses and the original configured storage mount paths. -- Replacement storage with capacity appropriate for the affected erasure set. -- The RustFS [`rc`](/operations/rc) client on a secured administration host. -- Administrative credentials that permit cluster information, scanner, and heal operations. -- A maintenance window when replacing hardware or running a deep recursive scan. +- Eine RustFS-Bereitstellung, die noch genug gesunde Shards hat, um die betroffenen Daten zu rekonstruieren. +- Stabile Knotenadressen und die ursprünglich konfigurierten Einhängepfade des Speichers. +- Ersatzspeicher mit einer Kapazität, die zum betroffenen Erasure-Set passt. +- Den RustFS-Client [`rc`](/de/operations/rc) auf einem abgesicherten Administrationshost. +- Administrative Zugangsdaten, die Clusterinformationen, Scanner und Datenwiederherstellung erlauben. +- Ein Wartungsfenster, wenn Sie Hardware ersetzen oder einen tiefen rekursiven Scan ausführen. -Record the failed node, pool, set, disk endpoint, mount path, and file-system UUID before changing hardware. Do not remove additional disks from the same erasure set while recovery is incomplete. +Notieren Sie den ausgefallenen Knoten, den Speicherpool, das Set, den Laufwerksendpunkt, den Einhängepfad und die UUID des Dateisystems, bevor Sie Hardware ändern. Entfernen Sie keine weiteren Laufwerke aus demselben Erasure-Set, solange die Wiederherstellung nicht abgeschlossen ist. -## 1. Identify the failed component +## 1. Ausgefallene Komponente identifizieren -Configure an `rc` alias if you do not already have one: +Konfigurieren Sie einen `rc`-Alias, falls Sie noch keinen haben: ```bash rc alias set rustfs https://rustfs.example.com:9000 \ @@ -54,7 +54,7 @@ rc alias set rustfs https://rustfs.example.com:9000 \ --region us-east-1 --bucket-lookup path ``` -Check cluster readiness, topology, storage health, and heal activity: +Prüfen Sie Clusterbereitschaft, Topologie, Speicherintegrität und Aktivität der Datenwiederherstellung: ```bash rc ready rustfs @@ -64,35 +64,35 @@ rc admin scanner status rustfs rc admin heal status rustfs ``` -Readiness can fail while the cluster is degraded. Use the administrative information commands to identify which node or disk is unavailable and note its pool and erasure-set location. +Die Bereitschaft kann fehlschlagen, während der Cluster beeinträchtigt ist. Nutzen Sie die administrativen Informationsbefehle, um zu erkennen, welcher Knoten oder welches Laufwerk nicht verfügbar ist, und notieren Sie Speicherpool und Position im Erasure-Set. -For machine-readable output, request JSON: +Fordern Sie für maschinenlesbare Ausgabe JSON an: ```bash rc --json admin info storage rustfs rc --json admin heal status rustfs ``` -The aggregate heal status reports runtime state, queued and active tasks, retrying work, request sources, priorities, and available progress counters. A zero-length queue does not prove that an offline disk has been replaced or that every object is recoverable; correlate it with storage topology and readiness. +Der zusammengefasste Status der Datenwiederherstellung meldet den Laufzeitzustand, eingereihte und aktive Aufgaben, erneut versuchte Arbeit, Anfragequellen, Prioritäten und verfügbare Fortschrittszähler. Eine Warteschlange der Länge null belegt nicht, dass ein offline geschaltetes Laufwerk ersetzt wurde oder dass jedes Objekt wiederherstellbar ist. Gleichen Sie sie mit Speichertopologie und Bereitschaft ab. -## 2. Restore the node or disk +## 2. Knoten oder Laufwerk wiederherstellen -Correct the underlying failure before starting a manual heal. +Beheben Sie den zugrunde liegenden Ausfall, bevor Sie eine manuelle Datenwiederherstellung starten. -For a node outage: +Bei einem Knotenausfall: -1. Restore the node's configured network identity and connectivity to every other RustFS node on the S3 API port, normally `9000`. -2. Mount the original data disks at their configured paths. -3. Confirm that the RustFS process uses the same storage endpoint configuration as the rest of the cluster. -4. Start RustFS and verify that the node rejoins the cluster. +1. Stellen Sie die konfigurierte Netzwerkidentität des Knotens und die Konnektivität zu jedem anderen RustFS-Knoten auf dem S3-API-Port wieder her, normalerweise `9000`. +2. Hängen Sie die ursprünglichen Datenlaufwerke an ihren konfigurierten Pfaden ein. +3. Bestätigen Sie, dass der RustFS-Prozess dieselbe Konfiguration der Speicherendpunkte verwendet wie der Rest des Clusters. +4. Starten Sie RustFS und prüfen Sie, dass der Knoten dem Cluster wieder beitritt. -For a failed disk: +Bei einem ausgefallenen Laufwerk: -1. Stop the RustFS process on the affected node before removing or remounting storage. -2. Replace the failed device and prepare its file system according to [Disk Preparation](/installation/requirement/disk-preparation). -3. Mount the replacement at the exact path used by the failed disk and update `/etc/fstab` with its file-system UUID. -4. Verify the mount, file-system type, ownership, and available capacity before starting RustFS. -5. Start RustFS and confirm that the disk appears in the expected pool and erasure set. +1. Stoppen Sie den RustFS-Prozess auf dem betroffenen Knoten, bevor Sie Speicher entfernen oder neu einhängen. +2. Ersetzen Sie das ausgefallene Gerät und bereiten Sie sein Dateisystem gemäß [Laufwerke vorbereiten](/de/installation/requirement/disk-preparation) vor. +3. Hängen Sie den Ersatz am exakten Pfad des ausgefallenen Laufwerks ein und aktualisieren Sie `/etc/fstab` mit der UUID seines Dateisystems. +4. Prüfen Sie Einhängung, Dateisystemtyp, Eigentümerschaft und verfügbare Kapazität, bevor Sie RustFS starten. +5. Starten Sie RustFS und bestätigen Sie, dass das Laufwerk im erwarteten Speicherpool und Erasure-Set erscheint. ```bash findmnt /data/rustfs0 @@ -100,15 +100,15 @@ df -hT /data/rustfs0 rc admin info storage rustfs ``` -:::warning[Do not reuse stale storage blindly] +:::warning[Verwenden Sie veralteten Speicher nicht unbesehen weiter] -Confirm the identity and contents of every device before mounting it at a RustFS data path. Do not copy internal metadata between disks, combine multiple configured endpoints on one replacement file system, or mount a replacement over a path that still contains required data. +Bestätigen Sie Identität und Inhalt jedes Geräts, bevor Sie es an einem RustFS-Datenpfad einhängen. Kopieren Sie interne Metadaten nicht zwischen Laufwerken, legen Sie nicht mehrere konfigurierte Endpunkte auf ein Ersatzdateisystem und hängen Sie einen Ersatz nicht über einen Pfad ein, der noch benötigte Daten enthält. ::: -## 3. Monitor automatic healing +## 3. Automatische Datenwiederherstellung überwachen -After the node or replacement disk is online, RustFS can detect the recovery candidate and queue erasure-set healing. Check both storage state and aggregate heal activity: +Nachdem der Knoten oder das Ersatzlaufwerk online ist, kann RustFS den Wiederherstellungskandidaten erkennen und die Datenwiederherstellung des Erasure-Sets einreihen. Prüfen Sie sowohl den Speicherzustand als auch die zusammengefasste Aktivität der Datenwiederherstellung: ```bash rc admin info storage rustfs @@ -116,24 +116,24 @@ rc admin heal status rustfs rc admin scanner status rustfs ``` -In JSON output, watch these groups: +Beobachten Sie in der JSON-Ausgabe diese Gruppen: -| Field | Meaning | +| Feld | Bedeutung | | --- | --- | -| `state` | Heal runtime state, such as `active` or `idle`. | -| `healQueueLength` | Total work waiting in the heal queue. | -| `healActiveTasks` | Total heal tasks currently running. | -| `healOperations` | Queue, active, and retry counts grouped by source (`scanner`, `admin`, `autoHeal`, `internal`, and `readRepair`) and priority. | -| `progress` | Available totals for objects scanned, healed, failed, and bytes processed. | -| `clusterStatusComplete` | Whether the response includes every expected node. | +| `state` | Laufzeitzustand der Datenwiederherstellung, etwa `active` oder `idle`. | +| `healQueueLength` | Gesamte Arbeit, die in der Heal-Warteschlange wartet. | +| `healActiveTasks` | Gesamtzahl der derzeit laufenden Heal-Aufgaben. | +| `healOperations` | Warteschlange, aktive Aufgaben und erneute Versuche, gruppiert nach Quelle (`scanner`, `admin`, `autoHeal`, `internal` und `readRepair`) und Priorität. | +| `progress` | Verfügbare Summen für gescannte, wiederhergestellte und fehlgeschlagene Objekte sowie verarbeitete Bytes. | +| `clusterStatusComplete` | Ob die Antwort jeden erwarteten Knoten enthält. | -Do not treat `idle` as successful recovery by itself. Confirm that the replacement disk is online, no heal failures remain, the cluster is ready, and representative objects are readable. +Werten Sie `idle` nicht für sich allein als erfolgreiche Wiederherstellung. Bestätigen Sie, dass das Ersatzlaufwerk online ist, keine Fehler der Datenwiederherstellung übrig sind, der Cluster bereit ist und repräsentative Objekte lesbar sind. -## 4. Run a targeted manual heal +## 4. Gezielte manuelle Datenwiederherstellung ausführen -Use a manual task when automatic recovery does not cover the required path or when you need an explicit scan after an incident. Start with the narrowest bucket or prefix that contains affected data. +Verwenden Sie eine manuelle Aufgabe, wenn die automatische Wiederherstellung den erforderlichen Pfad nicht abdeckt oder wenn Sie nach einem Vorfall einen ausdrücklichen Scan brauchen. Beginnen Sie mit dem engsten Bucket oder Präfix, der die betroffenen Daten enthält. -Preview a bucket heal without applying changes: +Sehen Sie eine Bucket-Datenwiederherstellung in der Vorschau an, ohne Änderungen anzuwenden: ```bash rc admin heal start rustfs \ @@ -142,7 +142,7 @@ rc admin heal start rustfs \ --dry-run ``` -Run the targeted heal after reviewing the preview: +Führen Sie die gezielte Datenwiederherstellung aus, nachdem Sie die Vorschau geprüft haben: ```bash rc admin heal start rustfs \ @@ -150,7 +150,7 @@ rc admin heal start rustfs \ --scan-mode normal ``` -Limit the task to an object prefix when the affected scope is known: +Begrenzen Sie die Aufgabe auf ein Objektpräfix, wenn der betroffene Umfang bekannt ist: ```bash rc admin heal start rustfs \ @@ -159,19 +159,19 @@ rc admin heal start rustfs \ --scan-mode deep ``` -`normal` is the default scan mode. Use `deep` when you need deeper data verification and have planned for the additional disk I/O. Omit `--bucket` only when a recursive scan of all buckets is necessary. +`normal` ist der Standard-Scanmodus. Verwenden Sie `deep`, wenn Sie eine tiefere Datenprüfung brauchen und die zusätzliche Laufwerks-E/A eingeplant haben. Lassen Sie `--bucket` nur weg, wenn ein rekursiver Scan aller Buckets nötig ist. -:::warning[Review mutation options separately] +:::warning[Prüfen Sie ändernde Optionen getrennt] -The `--remove` option removes dangling objects or parts, and `--recreate` requests recreation of missing data. Do not add either option to an incident command until you have inspected the affected storage state, tested with `--dry-run`, and confirmed the intended result. +Die Option `--remove` entfernt verwaiste Objekte oder Teile, und `--recreate` fordert die Neuerzeugung fehlender Daten an. Fügen Sie keine der beiden Optionen zu einem Störungsbefehl hinzu, bevor Sie den betroffenen Speicherzustand eingesehen, mit `--dry-run` getestet und das beabsichtigte Ergebnis bestätigt haben. ::: -## 5. Track the manual task +## 5. Manuelle Aufgabe verfolgen -Every manual heal returns a `clientToken`. Save it with the incident record because status and stop operations for that task require the token. +Jede manuelle Datenwiederherstellung liefert ein `clientToken`. Speichern Sie es mit dem Vorfallsdatensatz, weil Status- und Stopp-Operationen für diese Aufgabe das Token erfordern. -For a bucket or prefix task, pass the original target and token: +Übergeben Sie für eine Bucket- oder Präfixaufgabe das ursprüngliche Ziel und das Token: ```bash rc admin heal status rustfs \ @@ -180,23 +180,23 @@ rc admin heal status rustfs \ --client-token ``` -For a recursive task started without `--bucket`, use the token alone: +Verwenden Sie für eine rekursive Aufgabe, die ohne `--bucket` gestartet wurde, nur das Token: ```bash rc admin heal status rustfs --client-token ``` -The tokenless command remains the cluster-wide background summary: +Der Befehl ohne Token bleibt die clusterweite Hintergrundzusammenfassung: ```bash rc admin heal status rustfs ``` -Task status can include scanned, healed, and failed item totals, bytes processed, the current item, scan mode, start time, and last update. Investigate failed items rather than relying only on the task's aggregate state. +Der Aufgabenstatus kann Summen gescannter, wiederhergestellter und fehlgeschlagener Elemente, verarbeitete Bytes, das aktuelle Element, den Scanmodus, die Startzeit und die letzte Aktualisierung enthalten. Prüfen Sie fehlgeschlagene Elemente, statt sich nur auf den zusammengefassten Zustand der Aufgabe zu verlassen. -## 6. Validate recovery +## 6. Wiederherstellung prüfen -After the heal queue drains, verify the cluster and the recovered data path: +Prüfen Sie nach dem Leeren der Heal-Warteschlange den Cluster und den Pfad der wiederhergestellten Daten: ```bash rc ready rustfs @@ -205,20 +205,20 @@ rc admin info storage rustfs rc admin heal status rustfs ``` -Read representative objects from affected buckets and versions. For a known test object: +Lesen Sie repräsentative Objekte aus betroffenen Buckets und Versionen. Für ein bekanntes Testobjekt: ```bash rc object stat rustfs/my-bucket/hello.txt rc object copy rustfs/my-bucket/hello.txt ./hello-recovered.txt ``` -Compare the downloaded object with an independent checksum or trusted source when one is available. A successful object read validates that request, not every object or every shard in the cluster. +Vergleichen Sie das heruntergeladene Objekt mit einer unabhängigen Prüfsumme oder einer vertrauenswürdigen Quelle, wenn eine verfügbar ist. Ein erfolgreiches Lesen eines Objekts prüft diese Anfrage, nicht jedes Objekt und nicht jeden Shard im Cluster. -Continue monitoring storage health and heal failures after the cluster becomes ready. Preserve the incident timeline, failed-device information, task token, and final status output for review. +Beobachten Sie Speicherintegrität und Fehler der Datenwiederherstellung weiter, nachdem der Cluster bereit ist. Bewahren Sie den zeitlichen Ablauf des Vorfalls, die Angaben zum ausgefallenen Gerät, das Aufgabentoken und die endgültige Statusausgabe für die Nachbetrachtung auf. -## 7. Stop a manual heal +## 7. Manuelle Datenwiederherstellung stoppen -Stop only the task you have identified. For a bucket or prefix task, include the original target and token: +Stoppen Sie nur die Aufgabe, die Sie identifiziert haben. Nehmen Sie für eine Bucket- oder Präfixaufgabe das ursprüngliche Ziel und das Token auf: ```bash rc admin heal stop rustfs \ @@ -227,44 +227,44 @@ rc admin heal stop rustfs \ --client-token ``` -Stop a recursive token-scoped task with: +Stoppen Sie eine rekursive, an ein Token gebundene Aufgabe mit: ```bash rc admin heal stop rustfs --client-token ``` -The tokenless stop command targets the global background heal operation: +Der Stopp-Befehl ohne Token zielt auf den globalen Hintergrundvorgang der Datenwiederherstellung: ```bash rc admin heal stop rustfs ``` -Use the global stop only when continued background work creates a larger operational risk. Stopping healing leaves recovery incomplete; record the reason and confirm how healing will resume before closing the incident. +Verwenden Sie den globalen Stopp nur, wenn fortgesetzte Hintergrundarbeit ein größeres Betriebsrisiko erzeugt. Wenn Sie die Datenwiederherstellung stoppen, bleibt die Wiederherstellung unvollständig. Notieren Sie den Grund und bestätigen Sie, wie die Datenwiederherstellung fortgesetzt wird, bevor Sie den Vorfall schließen. -## Troubleshooting +## Fehlerbehebung -### The replacement disk is not healing +### Das Ersatzlaufwerk wird nicht wiederhergestellt -Confirm that the replacement is mounted at the configured endpoint and appears in `rc admin info storage`. Check the RustFS logs for disk identification, formatting, permission, or queue-admission failures. Also confirm that healing services are initialized with `rc admin heal status`. +Bestätigen Sie, dass der Ersatz am konfigurierten Endpunkt eingehängt ist und in `rc admin info storage` erscheint. Prüfen Sie die RustFS-Protokolle auf Fehler bei der Laufwerksidentifikation, der Formatierung, den Berechtigungen oder der Zulassung zur Warteschlange. Bestätigen Sie außerdem, dass die Dienste der Datenwiederherstellung initialisiert sind, mit `rc admin heal status`. -### Heal status is partial +### Der Status der Datenwiederherstellung ist unvollständig -If `clusterStatusComplete` is false, one or more expected nodes did not contribute to the aggregate response. Restore node-to-node connectivity and check each node's storage and process health before trusting cluster totals. +Wenn `clusterStatusComplete` falsch ist, hat mindestens ein erwarteter Knoten nicht zur zusammengefassten Antwort beigetragen. Stellen Sie die Konnektivität von Knoten zu Knoten wieder her und prüfen Sie Speicher und Prozesszustand jedes Knotens, bevor Sie Cluster-Summen vertrauen. -### The queue remains active +### Die Warteschlange bleibt aktiv -Compare queued, active, and retrying work by source. A growing `autoHeal` count points to disk or erasure-set recovery; scanner work points to background discovery; admin work belongs to manually submitted tasks. Check disk latency, free capacity, node connectivity, and repeated item failures before starting another task. +Vergleichen Sie eingereihte, aktive und erneut versuchte Arbeit nach Quelle. Eine wachsende Zahl `autoHeal` weist auf die Wiederherstellung von Laufwerk oder Erasure-Set hin. Scanner-Arbeit weist auf Entdeckung im Hintergrund hin. Admin-Arbeit gehört zu manuell eingereichten Aufgaben. Prüfen Sie Laufwerkslatenz, freie Kapazität, Knotenkonnektivität und wiederholte Elementfehler, bevor Sie eine weitere Aufgabe starten. -### Objects cannot be reconstructed +### Objekte lassen sich nicht rekonstruieren -Stop additional maintenance on the affected erasure set. Preserve the remaining disks and logs, then determine whether enough healthy shards survive. Repeated deep scans cannot reconstruct data when the available redundancy has already been exceeded. +Stoppen Sie weitere Wartung am betroffenen Erasure-Set. Bewahren Sie die verbleibenden Laufwerke und Protokolle auf und stellen Sie dann fest, ob genug gesunde Shards überleben. Wiederholte tiefe Scans können Daten nicht rekonstruieren, wenn die verfügbare Redundanz bereits überschritten ist. -### A manual task cannot be queried +### Eine manuelle Aufgabe lässt sich nicht abfragen -Use the `clientToken` returned by `heal start`. Bucket and prefix tasks must be queried with the same `--bucket` and `--prefix` target used at start; a recursive root task uses the token without a bucket. +Verwenden Sie das `clientToken`, das `heal start` zurückgegeben hat. Bucket- und Präfixaufgaben müssen mit demselben Ziel aus `--bucket` und `--prefix` abgefragt werden, das beim Start verwendet wurde. Eine rekursive Root-Aufgabe verwendet das Token ohne Bucket. -## Next steps +## Nächste Schritte -- Review [Status Check](/operations/status-check) for readiness, cluster, and capacity checks. -- Configure [Observability](/operations/observability) to alert on disk health and sustained recovery work. -- Review [Site Replication](/operations/high-availability/site-replication) when recovery requires an independent RustFS deployment. +- Lesen Sie [Statusprüfung](/de/operations/status-check) für Prüfungen von Bereitschaft, Cluster und Kapazität. +- Konfigurieren Sie [Observability](/de/operations/observability), um bei Laufwerksintegrität und anhaltender Wiederherstellungsarbeit zu alarmieren. +- Lesen Sie [Site-Replikation](/de/operations/high-availability/site-replication), wenn die Wiederherstellung eine unabhängige RustFS-Bereitstellung erfordert. diff --git a/content/de/operations/high-availability/site-replication.md b/content/de/operations/high-availability/site-replication.md index fb7ff8a1f..15acb740c 100644 --- a/content/de/operations/high-availability/site-replication.md +++ b/content/de/operations/high-availability/site-replication.md @@ -1,51 +1,51 @@ --- -title: "Site Replication" -description: "Configure and operate multi-site RustFS replication with the rc command-line client." +title: "Site-Replikation" +description: "Konfigurieren und betreiben Sie die RustFS-Replikation über mehrere Standorte mit dem Kommandozeilenclient rc." --- -Site replication links two or more independent **RustFS** deployments. It synchronizes buckets, object versions, and supported identity and access management (IAM) data across the linked sites. Use this workflow when applications need to write to separate RustFS sites while keeping their storage and identity configuration aligned. +Die Site-Replikation verknüpft zwei oder mehr unabhängige **RustFS**-Bereitstellungen. Sie synchronisiert Buckets, Objektversionen und unterstützte Daten der Identitäts- und Zugriffsverwaltung (IAM) über die verknüpften Standorte. Verwenden Sie diesen Ablauf, wenn Anwendungen auf getrennte RustFS-Standorte schreiben müssen und dabei Speicher und Identitätskonfiguration abgeglichen bleiben sollen. -Site replication is different from [bucket replication](/administration/data/bucket/replication). Bucket replication is a directional rule between selected buckets; site replication establishes a broader relationship between complete RustFS deployments. +Die Site-Replikation unterscheidet sich von der [Bucket-Replikation](/de/administration/data/bucket/replication). Die Bucket-Replikation ist eine gerichtete Regel zwischen ausgewählten Buckets. Die Site-Replikation stellt eine breitere Beziehung zwischen vollständigen RustFS-Bereitstellungen her. -:::warning[Plan recovery separately] +:::warning[Planen Sie die Wiederherstellung getrennt] -Site replication is asynchronous. A successful write at one site does not confirm that another site already has the replicated version. Site replication also does not provide DNS failover, traffic routing, or application recovery orchestration. +Die Site-Replikation ist asynchron. Ein erfolgreicher Schreibvorgang an einem Standort bestätigt nicht, dass ein anderer Standort die replizierte Version bereits hat. Die Site-Replikation bietet außerdem kein DNS-Failover, keine Verkehrslenkung und keine Orchestrierung der Anwendungswiederherstellung. ::: -## Replicated resources +## Replizierte Ressourcen -RustFS site replication synchronizes these resource families across linked sites: +Die RustFS-Site-Replikation synchronisiert diese Ressourcenfamilien über verknüpfte Standorte: -- Buckets and object versions, including delete markers. -- Bucket metadata required by the site replication workflow. -- IAM users, groups, policies, policy mappings, and service accounts. +- Buckets und Objektversionen, einschließlich Löschmarkierungen. +- Bucket-Metadaten, die der Ablauf der Site-Replikation benötigt. +- IAM-Benutzer, Gruppen, Richtlinien, Richtlinienzuordnungen und Servicekonten. -Bucket versioning support is required at every participating site. RustFS configures the site relationship and the underlying replication targets when you add the sites. +Die Unterstützung der Bucket-Versionierung ist an jedem beteiligten Standort erforderlich. RustFS konfiguriert die Standortbeziehung und die zugrunde liegenden Replikationsziele, wenn Sie die Standorte hinzufügen. -## Requirements +## Voraussetzungen -Before linking sites, prepare: +Bereiten Sie vor dem Verknüpfen der Standorte Folgendes vor: -- Two or more independent RustFS deployments running a release that exposes the site replication Admin API. -- A unique, stable S3 API endpoint for each deployment. -- Bidirectional network connectivity between every site endpoint on the S3 API port, normally `9000`. -- Trusted TLS certificates for production endpoints. -- The RustFS [`rc`](/operations/rc) client on a secured administration host. -- Root administrative credentials for every participating site. -- Compatible bucket-versioning support on every site. +- Zwei oder mehr unabhängige RustFS-Bereitstellungen, die ein Release ausführen, das die Admin-API der Site-Replikation bereitstellt. +- Einen eindeutigen, stabilen S3-API-Endpunkt für jede Bereitstellung. +- Bidirektionale Netzwerkkonnektivität zwischen jedem Standort-Endpunkt auf dem S3-API-Port, normalerweise `9000`. +- Vertrauenswürdige TLS-Zertifikate für Produktionsendpunkte. +- Den RustFS-Client [`rc`](/de/operations/rc) auf einem abgesicherten Administrationshost. +- Root-Anmeldedaten für die Verwaltung jedes beteiligten Standorts. +- Kompatible Unterstützung der Bucket-Versionierung an jedem Standort. -Use empty test sites when first validating the workflow. Before linking existing sites, inventory bucket names, object-lock settings, IAM identities, and policies for conflicts. +Verwenden Sie leere Teststandorte, wenn Sie den Ablauf zum ersten Mal prüfen. Inventarisieren Sie vor dem Verknüpfen vorhandener Standorte Bucket-Namen, Einstellungen von Object Lock, IAM-Identitäten und Richtlinien auf Konflikte. -:::warning[Protect administrative credentials] +:::warning[Schützen Sie administrative Anmeldedaten] -The `add` operation resolves every peer endpoint and root credential from your local `rc` alias store. Run it only from a trusted administration host, restrict access to the local `rc` configuration, and do not place credentials in shell history, logs, or screenshots. +Die Operation `add` löst jeden Peer-Endpunkt und die Root-Anmeldedaten aus Ihrem lokalen Alias-Speicher von `rc` auf. Führen Sie sie nur von einem vertrauenswürdigen Administrationshost aus, beschränken Sie den Zugriff auf die lokale `rc`-Konfiguration und legen Sie Anmeldedaten nicht in der Shell-Historie, in Protokollen oder in Bildschirmfotos ab. ::: -## 1. Configure site aliases +## 1. Standort-Aliase konfigurieren -Configure one alias for each site. Replace the endpoint and credentials for both deployments: +Konfigurieren Sie einen Alias je Standort. Ersetzen Sie Endpunkt und Anmeldedaten für beide Bereitstellungen: ```bash rc alias set site1 https://site1.example.com:9000 \ @@ -57,7 +57,7 @@ rc alias set site2 https://site2.example.com:9000 \ --region us-east-1 --bucket-lookup path ``` -Check that both sites are reachable and ready: +Prüfen Sie, dass beide Standorte erreichbar und bereit sind: ```bash rc ready site1 @@ -66,48 +66,48 @@ rc admin info cluster site1 rc admin info cluster site2 ``` -Use HTTPS endpoints in production. If a site uses a private certificate authority, install that authority in the administration host's trust store before continuing. +Verwenden Sie in der Produktion HTTPS-Endpunkte. Wenn ein Standort eine private Zertifizierungsstelle verwendet, installieren Sie diese Zertifizierungsstelle im Vertrauensspeicher des Administrationshosts, bevor Sie fortfahren. -:::warning[Loopback endpoints are for tests only] +:::warning[Loopback-Endpunkte sind nur für Tests] -RustFS rejects loopback replication targets by default as an outbound-request security control. The server option `RUSTFS_REPLICATION_ALLOW_LOOPBACK_TARGET=true` exists only for single-host development and automated tests. Never enable it in production. +RustFS lehnt Loopback-Replikationsziele standardmäßig ab, als Schutz für ausgehende Anfragen. Die Serveroption `RUSTFS_REPLICATION_ALLOW_LOOPBACK_TARGET=true` existiert nur für die Entwicklung auf einem einzelnen Host und für automatisierte Tests. Aktivieren Sie sie in der Produktion niemals. ::: -## 2. Link the sites +## 2. Standorte verknüpfen -Submit all participating aliases in one command. The first alias receives the administration request: +Übergeben Sie alle beteiligten Aliase in einem Befehl. Der erste Alias empfängt die Verwaltungsanfrage: ```bash rc admin replicate add site1 site2 ``` -To create a relationship with more than two sites, include every alias in the initial command: +Um eine Beziehung mit mehr als zwei Standorten anzulegen, nehmen Sie jeden Alias in den ersten Befehl auf: ```bash rc admin replicate add site1 site2 site3 ``` -Do not run separate pairwise `add` commands to build the same multi-site relationship. +Führen Sie keine getrennten paarweisen `add`-Befehle aus, um dieselbe Beziehung über mehrere Standorte aufzubauen. -Inspect the resulting configuration from at least two sites: +Prüfen Sie die entstandene Konfiguration von mindestens zwei Standorten: ```bash rc admin replicate info site1 rc admin replicate info site2 ``` -The output identifies each linked deployment by its deployment ID, site name, and endpoint. Save the deployment IDs because edit and resync operations can select a site by exact deployment ID or exact unique name. +Die Ausgabe identifiziert jede verknüpfte Bereitstellung über ihre Bereitstellungs-ID, den Standortnamen und den Endpunkt. Speichern Sie die Bereitstellungs-IDs, weil Bearbeitung und Resynchronisation einen Standort über die genaue Bereitstellungs-ID oder den genauen eindeutigen Namen auswählen können. -## 3. Check replication status +## 3. Replikationsstatus prüfen -Request the default bucket and IAM summaries: +Fordern Sie die Standardzusammenfassungen für Buckets und IAM an: ```bash rc admin replicate status site1 ``` -Select specific status sections when investigating an issue: +Wählen Sie bestimmte Statusabschnitte, wenn Sie ein Problem eingrenzen: ```bash rc admin replicate status site1 --buckets @@ -115,11 +115,11 @@ rc admin replicate status site1 --users --groups --policies rc admin replicate status site1 --metrics ``` -Check status from each site. A healthy response from `site1` confirms that site's view of the relationship; it does not replace checking the other deployments. +Prüfen Sie den Status von jedem Standort. Eine intakte Antwort von `site1` bestätigt die Sicht dieses Standorts auf die Beziehung. Sie ersetzt die Prüfung der anderen Bereitstellungen nicht. -## 4. Validate data and IAM replication +## 4. Daten- und IAM-Replikation prüfen -Create a test bucket and object at the first site: +Legen Sie am ersten Standort einen Test-Bucket und ein Testobjekt an: ```bash rc bucket create site1/my-bucket @@ -127,20 +127,20 @@ printf 'hello rustfs\n' > hello.txt rc object copy hello.txt site1/my-bucket/hello.txt ``` -Poll the second site until the object appears: +Fragen Sie den zweiten Standort ab, bis das Objekt erscheint: ```bash rc object stat site2/my-bucket/hello.txt rc object copy site2/my-bucket/hello.txt ./hello-from-site2.txt ``` -Compare the downloaded content before treating the data path as validated: +Vergleichen Sie den heruntergeladenen Inhalt, bevor Sie den Datenpfad als geprüft behandeln: ```bash cmp hello.txt hello-from-site2.txt ``` -For IAM validation, create a temporary user and attach a test policy at one site, then inspect the user and policy mapping at another site. Remove the temporary identity after validation: +Legen Sie für die IAM-Prüfung an einem Standort einen temporären Benutzer an und hängen Sie eine Testrichtlinie an. Sehen Sie danach Benutzer und Richtlinienzuordnung an einem anderen Standort ein. Entfernen Sie die temporäre Identität nach der Prüfung: ```bash rc admin user add site1 replication-test @@ -152,17 +152,17 @@ rc admin policy entities site2 --user replication-test rc admin user rm site1 replication-test ``` -Use a randomly generated temporary secret and do not reuse an application or administrator credential. +Verwenden Sie ein zufällig erzeugtes temporäres Geheimnis und verwenden Sie keine Anmeldedaten einer Anwendung oder eines Administrators wieder. -## 5. Edit a site +## 5. Einen Standort bearbeiten -Use `edit` when a linked site's name, endpoint, or TLS trust settings change. First inspect the current deployment IDs and names: +Verwenden Sie `edit`, wenn sich Name, Endpunkt oder TLS-Vertrauenseinstellungen eines verknüpften Standorts ändern. Sehen Sie zuerst die aktuellen Bereitstellungs-IDs und Namen ein: ```bash rc admin replicate info site1 ``` -Rename a site: +Benennen Sie einen Standort um: ```bash rc admin replicate edit site1 \ @@ -171,7 +171,7 @@ rc admin replicate edit site1 \ --yes ``` -Replace an endpoint and keep TLS verification enabled: +Ersetzen Sie einen Endpunkt und lassen Sie die TLS-Prüfung aktiviert: ```bash rc admin replicate edit site1 \ @@ -181,7 +181,7 @@ rc admin replicate edit site1 \ --yes ``` -For a private certificate authority, provide a certificate-only PEM bundle: +Geben Sie für eine private Zertifizierungsstelle ein PEM-Bündel an, das nur Zertifikate enthält: ```bash rc admin replicate edit site1 \ @@ -190,7 +190,7 @@ rc admin replicate edit site1 \ --yes ``` -Clear a previously configured custom CA when the endpoint moves to a certificate trusted by the system trust store: +Löschen Sie eine zuvor konfigurierte eigene Zertifizierungsstelle, wenn der Endpunkt zu einem Zertifikat wechselt, dem der Systemvertrauensspeicher vertraut: ```bash rc admin replicate edit site1 \ @@ -200,11 +200,11 @@ rc admin replicate edit site1 \ --yes ``` -The endpoint must be an HTTP or HTTPS origin without a path, query, fragment, or embedded credentials. Prefer a trusted certificate over `--skip-tls-verify`. +Der Endpunkt muss ein HTTP- oder HTTPS-Ursprung ohne Pfad, Abfrage, Fragment oder eingebettete Anmeldedaten sein. Bevorzugen Sie ein vertrauenswürdiges Zertifikat gegenüber `--skip-tls-verify`. -## 6. Resynchronize a site +## 6. Einen Standort neu synchronisieren -Use resynchronization after repairing a site that was unavailable or when status checks show missing replicated state. Start a resync for one exact peer: +Verwenden Sie die Resynchronisation, nachdem Sie einen Standort repariert haben, der nicht verfügbar war, oder wenn Statusprüfungen fehlenden replizierten Zustand zeigen. Starten Sie eine Resynchronisation für genau einen Peer: ```bash rc admin replicate resync start site1 \ @@ -212,14 +212,14 @@ rc admin replicate resync start site1 \ --yes ``` -Read the last persisted resync snapshot: +Lesen Sie den zuletzt persistierten Resynchronisations-Snapshot: ```bash rc admin replicate resync status site1 \ --site ``` -Cancel the selected resync only when you have confirmed it should stop: +Brechen Sie die ausgewählte Resynchronisation nur ab, wenn Sie bestätigt haben, dass sie stoppen soll: ```bash rc admin replicate resync cancel site1 \ @@ -227,23 +227,23 @@ rc admin replicate resync cancel site1 \ --yes ``` -:::warning[Resync status is not live progress] +:::warning[Der Status der Resynchronisation zeigt keinen laufenden Fortschritt] -The current RustFS resync status endpoint returns the persisted result of the most recent start or cancel request. It does not inspect live workers, and its lifecycle state is reported as unknown. Start operations can overlap, cancellation is not idempotent, and a network timeout can leave the mutation outcome unknown. After an ambiguous result, inspect `replicate info`, `replicate status`, and the target data before issuing another mutation. +Der aktuelle Statusendpunkt der RustFS-Resynchronisation liefert das persistierte Ergebnis der letzten Start- oder Abbruchanfrage. Er sieht keine laufenden Worker, und sein Lebenszykluszustand wird als unbekannt gemeldet. Startvorgänge können sich überlappen, der Abbruch ist nicht idempotent, und ein Netzwerk-Zeitlimit kann das Ergebnis der Änderung unbekannt lassen. Sehen Sie nach einem mehrdeutigen Ergebnis `replicate info`, `replicate status` und die Zieldaten ein, bevor Sie eine weitere Änderung auslösen. ::: -## 7. Remove site replication +## 7. Site-Replikation entfernen -Removing a site changes the replication relationship. It does not provide an application cutover or prove that every queued object has arrived. Check status and preserve any required data before proceeding. +Das Entfernen eines Standorts ändert die Replikationsbeziehung. Es bietet keine Anwendungsumschaltung und belegt nicht, dass jedes eingereihte Objekt angekommen ist. Prüfen Sie den Status und bewahren Sie alle benötigten Daten auf, bevor Sie fortfahren. -Remove one named site: +Entfernen Sie einen benannten Standort: ```bash rc admin replicate remove site1 --site site2-dr ``` -Repeat `--site` to remove multiple named sites in one request: +Wiederholen Sie `--site`, um mehrere benannte Standorte in einer Anfrage zu entfernen: ```bash rc admin replicate remove site1 \ @@ -251,41 +251,41 @@ rc admin replicate remove site1 \ --site site3 ``` -Dissolve the complete site replication relationship: +Lösen Sie die vollständige Beziehung der Site-Replikation auf: ```bash rc admin replicate remove site1 --all ``` -Verify the result from the remaining deployments: +Prüfen Sie das Ergebnis von den verbleibenden Bereitstellungen: ```bash rc admin replicate info site1 rc admin replicate status site1 ``` -## Troubleshooting +## Fehlerbehebung -### A peer endpoint is rejected +### Ein Peer-Endpunkt wird abgelehnt -Confirm that the endpoint is a reachable HTTP or HTTPS origin and does not resolve to loopback. For production, make every site reachable through its stable network address and keep the loopback override disabled. +Bestätigen Sie, dass der Endpunkt ein erreichbarer HTTP- oder HTTPS-Ursprung ist und nicht auf Loopback auflöst. Machen Sie in der Produktion jeden Standort über seine stabile Netzwerkadresse erreichbar und lassen Sie die Loopback-Überschreibung deaktiviert. -### TLS validation fails +### Die TLS-Prüfung schlägt fehl -Confirm that the endpoint certificate contains the peer hostname and that the issuing certificate authority is trusted. Use `replicate edit --ca-cert` for a private CA bundle. Do not make `--skip-tls-verify` the permanent fix. +Bestätigen Sie, dass das Endpunktzertifikat den Hostnamen des Peers enthält und dass der Zertifizierungsstelle, die es ausgestellt hat, vertraut wird. Verwenden Sie `replicate edit --ca-cert` für ein Bündel einer privaten Zertifizierungsstelle. Machen Sie `--skip-tls-verify` nicht zur dauerhaften Abhilfe. -### A mutation times out +### Eine Änderung läuft in ein Zeitlimit -Do not immediately repeat `add`, `edit`, `resync start`, `resync cancel`, or `remove`. The server may have applied the change before the client lost the response. Inspect the relationship and data first: +Wiederholen Sie `add`, `edit`, `resync start`, `resync cancel` oder `remove` nicht sofort. Der Server kann die Änderung angewendet haben, bevor der Client die Antwort verloren hat. Sehen Sie zuerst die Beziehung und die Daten ein: ```bash rc admin replicate info site1 rc admin replicate status site1 ``` -### Replication falls behind +### Die Replikation fällt zurück -Check the site status and metrics from every deployment, then verify endpoint reachability and storage readiness: +Prüfen Sie Standortstatus und Metriken von jeder Bereitstellung und prüfen Sie dann Erreichbarkeit der Endpunkte und Speicherbereitschaft: ```bash rc admin replicate status site1 --metrics @@ -293,10 +293,10 @@ rc ready site1 rc ready site2 ``` -Application writes can outpace asynchronous replication. Do not infer a recovery point objective from a single status sample; measure lag under your workload and alert on sustained backlog. +Schreibvorgänge der Anwendung können der asynchronen Replikation vorauseilen. Leiten Sie kein Wiederherstellungsziel (Recovery Point Objective) aus einer einzelnen Statusprobe ab. Messen Sie die Verzögerung unter Ihrer Last und alarmieren Sie bei anhaltendem Rückstand. -## Next steps +## Nächste Schritte -- Review [Bucket Replication](/administration/data/bucket/replication) when you need directional replication for selected buckets instead of a complete site relationship. -- Monitor [cluster status and readiness](/operations/status-check) at every site. -- Review the [`rc` command guide](/operations/rc) and keep the client aligned with the RustFS server release. \ No newline at end of file +- Lesen Sie [Bucket-Replikation](/de/administration/data/bucket/replication), wenn Sie gerichtete Replikation für ausgewählte Buckets brauchen statt einer vollständigen Standortbeziehung. +- Überwachen Sie an jedem Standort [Clusterstatus und Bereitschaft](/de/operations/status-check). +- Lesen Sie die [`rc`-Befehlsanleitung](/de/operations/rc) und halten Sie den Client auf dem Release des RustFS-Servers. diff --git a/content/de/operations/index.md b/content/de/operations/index.md index a7bd20cca..ed1751993 100644 --- a/content/de/operations/index.md +++ b/content/de/operations/index.md @@ -1,16 +1,16 @@ --- -title: "Operations & Observability" -description: "Operate, monitor, scale, upgrade, and troubleshoot RustFS deployments." +title: "Betrieb und Observability" +description: "Betreiben, überwachen und skalieren Sie RustFS-Bereitstellungen, führen Sie Upgrades aus und beheben Sie Störungen." --- -Use this section to keep RustFS deployments healthy through upgrades, scaling, availability planning, monitoring, and incident response. +Nutzen Sie diesen Abschnitt, um RustFS-Bereitstellungen durch Upgrades, Skalierung, Verfügbarkeitsplanung, Überwachung und Reaktion auf Störungen betriebsbereit zu halten. -## Operational areas +## Operative Bereiche -- [Upgrade](./upgrade/index.md) covers binary, container, and Kubernetes upgrades. -- [Scaling](./scaling/index.md) covers storage expansion, rebalancing, and decommissioning. -- [High Availability](./high-availability/index.md) covers node healing and site replication. -- [Cluster Lifecycle Operations](./cluster-lifecycle.md) covers layout boundaries, quorum, expansion, rebalancing, decommissioning, healing, and restarts in one runbook. -- [Observability](./observability.md) covers metrics, logs, traces, monitoring integrations, and alert signals. -- [Status Check](./status-check.md) covers network ports, health probes, cluster status, and storage capacity checks. -- [Event Notifications](./event-notifications.md) covers bucket event targets. \ No newline at end of file +- [Upgrade](./upgrade/index.md) behandelt Upgrades für Binärdatei, Container und Kubernetes. +- [Skalierung](./scaling/index.md) behandelt Speichererweiterung, Rebalancing und Außerbetriebnahme. +- [Hochverfügbarkeit](./high-availability/index.md) behandelt die Datenwiederherstellung von Knoten und die Site-Replikation. +- [Cluster-Lebenszyklusoperationen](./cluster-lifecycle.md) behandeln Layoutgrenzen, Quorum, Erweiterung, Rebalancing, Außerbetriebnahme, Datenwiederherstellung und Neustarts in einem Runbook. +- [Observability](./observability.md) behandelt Metriken, Protokolle, Traces, Monitoring-Integrationen und Alarmsignale. +- [Statusprüfung](./status-check.md) behandelt Netzwerkports, Integritätsprüfungen, den Clusterstatus und Prüfungen der Speicherkapazität. +- [Ereignisbenachrichtigungen](./event-notifications.md) behandeln Ziele für Bucket-Ereignisse. diff --git a/content/de/operations/observability.md b/content/de/operations/observability.md index b0531ca3a..4c014c95b 100644 --- a/content/de/operations/observability.md +++ b/content/de/operations/observability.md @@ -1,11 +1,11 @@ --- title: "Observability" -description: "This article explains RustFS telemetry exports, monitoring integrations, metric names and labels, recommended alerts, and log collection." +description: "Exportieren Sie Metriken, Traces und Protokolle von RustFS über OTLP, binden Sie Monitoring-Werkzeuge ein und konfigurieren Sie empfohlene Alarme." --- -## How RustFS Exposes Telemetry +## Wie RustFS Telemetrie bereitstellt -RustFS **pushes** metrics, traces, and logs over OTLP (OpenTelemetry Protocol). It does **not** expose a native Prometheus `/metrics` scrape endpoint — there is no HTTP route on port 9000 or 9001 that serves Prometheus text format. To get RustFS metrics into Prometheus you must run an OpenTelemetry Collector that receives OTLP from RustFS and re-exposes the data in Prometheus format: +RustFS **sendet** Metriken, Traces und Protokolle über OTLP (OpenTelemetry Protocol). Es stellt **keinen** nativen Prometheus-Endpunkt `/metrics` zum Scrapen bereit. Auf Port 9000 oder 9001 gibt es keine HTTP-Route, die das Prometheus-Textformat ausliefert. Um RustFS-Metriken nach Prometheus zu bringen, müssen Sie einen OpenTelemetry Collector betreiben, der OTLP von RustFS empfängt und die Daten im Prometheus-Format erneut bereitstellt: ```text RustFS (RUSTFS_OBS_ENDPOINT) --OTLP--> OpenTelemetry Collector --> Prometheus --> Grafana @@ -13,27 +13,27 @@ RustFS (RUSTFS_OBS_ENDPOINT) --OTLP--> OpenTelemetry Collector --> Prometheus -- \--> Tempo / Jaeger (traces) ``` -Point RustFS at the Collector with: +Richten Sie RustFS auf den Collector aus: ```bash # OTLP over HTTP (the Collector's default HTTP receiver port is 4318; gRPC is 4317) RUSTFS_OBS_ENDPOINT=http://otel-collector:4318 ``` -Related environment variables (all defined in the server configuration): +Zugehörige Umgebungsvariablen (alle in der Serverkonfiguration definiert): -| Variable | Purpose | +| Variable | Zweck | | --- | --- | -| `RUSTFS_OBS_ENDPOINT` | Base OTLP endpoint for traces, metrics, and logs | -| `RUSTFS_OBS_TRACE_ENDPOINT` / `RUSTFS_OBS_METRIC_ENDPOINT` / `RUSTFS_OBS_LOG_ENDPOINT` | Per-signal endpoint overrides | -| `RUSTFS_OBS_METRICS_EXPORT_ENABLED` / `RUSTFS_OBS_TRACES_EXPORT_ENABLED` / `RUSTFS_OBS_LOGS_EXPORT_ENABLED` | Toggle each signal | -| `RUSTFS_OBS_METER_INTERVAL` | Metric export interval | -| `RUSTFS_OBS_SERVICE_NAME` / `RUSTFS_OBS_ENVIRONMENT` | Resource attributes attached to exported telemetry | -| `RUSTFS_OBS_LOGGER_LEVEL` | Log verbosity (e.g. `info`) | +| `RUSTFS_OBS_ENDPOINT` | Basis-OTLP-Endpunkt für Traces, Metriken und Protokolle | +| `RUSTFS_OBS_TRACE_ENDPOINT` / `RUSTFS_OBS_METRIC_ENDPOINT` / `RUSTFS_OBS_LOG_ENDPOINT` | Endpunktüberschreibungen je Signal | +| `RUSTFS_OBS_METRICS_EXPORT_ENABLED` / `RUSTFS_OBS_TRACES_EXPORT_ENABLED` / `RUSTFS_OBS_LOGS_EXPORT_ENABLED` | Schaltet jedes Signal ein oder aus | +| `RUSTFS_OBS_METER_INTERVAL` | Exportintervall der Metriken | +| `RUSTFS_OBS_SERVICE_NAME` / `RUSTFS_OBS_ENVIRONMENT` | Ressourcenattribute, die an die exportierte Telemetrie gehängt werden | +| `RUSTFS_OBS_LOGGER_LEVEL` | Protokollausführlichkeit (z. B. `info`) | -## Reference Deployment (Docker Compose Observability Profile) +## Referenzbereitstellung (Observability-Profil von Docker Compose) -The upstream `rustfs/rustfs` repository ships a complete reference stack in `docker-compose.yml` behind the `observability` profile: **otel-collector**, **Prometheus**, **Grafana**, **Loki** (logs), **Tempo** and **Jaeger** (traces). Its Collector configuration receives OTLP on 4317 (gRPC) and 4318 (HTTP) and re-exports metrics for Prometheus on port `8889`: +Das Upstream-Repository `rustfs/rustfs` liefert in `docker-compose.yml` hinter dem Profil `observability` einen vollständigen Referenzstapel: **otel-collector**, **Prometheus**, **Grafana**, **Loki** (Protokolle), **Tempo** und **Jaeger** (Traces). Die Collector-Konfiguration empfängt OTLP auf 4317 (gRPC) und 4318 (HTTP) und exportiert Metriken für Prometheus erneut auf Port `8889`: ```yaml # OpenTelemetry Collector (excerpt from the upstream reference config) @@ -54,7 +54,7 @@ service: exporters: [prometheus] ``` -Prometheus then scrapes the Collector, not RustFS: +Prometheus scrapt danach den Collector, nicht RustFS: ```yaml # prometheus.yml (excerpt) @@ -69,150 +69,150 @@ scrape_configs: :::note -If Prometheus shows no `rustfs_*` series, check the chain in order: is `RUSTFS_OBS_ENDPOINT` set on every node, is the Collector reachable from the nodes, and is Prometheus scraping the Collector's `8889` exporter port. +Wenn Prometheus keine Zeitreihen `rustfs_*` zeigt, prüfen Sie die Kette der Reihe nach: Ist `RUSTFS_OBS_ENDPOINT` auf jedem Knoten gesetzt, ist der Collector von den Knoten erreichbar, und scrapt Prometheus den Exporter-Port `8889` des Collectors. ::: -## Metrics Reference +## Metrikreferenz -Every name below is verified against the server source. The list covers the operations-relevant subset exported via OTLP; internal and experimental instruments are omitted, and new releases may add metrics not listed here. Label sets are those recorded at the emission site. The Collector and Prometheus may attach additional resource labels, such as `service_name` and instance. +Jeder Name unten ist gegen den Serverquellcode geprüft. Die Liste umfasst die betrieblich relevante Teilmenge, die über OTLP exportiert wird. Interne und experimentelle Instrumente sind ausgelassen, und neue Versionen können Metriken hinzufügen, die hier nicht stehen. Die Label-Sätze sind die am Emissionsort aufgezeichneten. Collector und Prometheus können weitere Ressourcenlabels anhängen, etwa `service_name` und die Instanz. -### Readiness and Process +### Bereitschaft und Prozess -| Metric | Type | Labels | Meaning | +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_start_total` | counter | — | Process starts; a rising rate indicates restart loops | -| `rustfs_runtime_readiness_ready` | gauge | — | `1` when the node is fully ready, `0` while degraded | -| `rustfs_runtime_readiness_degraded_total` | counter | `reason` | Degraded readiness evaluations, by `degradedReasons` value (e.g. `storage_quorum_unavailable`) | +| `rustfs_start_total` | counter | — | Prozessstarts; eine steigende Rate weist auf Neustartschleifen hin | +| `rustfs_runtime_readiness_ready` | gauge | — | `1`, wenn der Knoten vollständig bereit ist, `0`, solange die Bereitschaft beeinträchtigt ist | +| `rustfs_runtime_readiness_degraded_total` | counter | `reason` | Auswertungen mit beeinträchtigter Bereitschaft, nach dem Wert von `degradedReasons` (z. B. `storage_quorum_unavailable`) | ### Scanner -| Metric | Type | Labels | Meaning | +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_scanner_objects_scanned_total` | counter | — | Objects visited by the background scanner | -| `rustfs_scanner_directories_scanned_total` | counter | — | Directories visited | -| `rustfs_scanner_buckets_scanned_total` | counter | `result`, `bucket`, `disk` | Bucket/drive scans completed, by outcome (`success` / `error` / `partial`) | -| `rustfs_scanner_cycles_total` | counter | `result` | Scanner cycles finished (`success` / `error` / `partial` / `unknown`) | -| `rustfs_scanner_cycle_duration_seconds` | gauge | — | Duration of the last completed scan cycle | -| `rustfs_scanner_bucket_drive_duration_seconds` | histogram | `bucket`, `disk` | Time to scan one bucket on one drive | -| `rustfs_scanner_leader_lock_total` | counter | `state` | Scanner leader-lock acquisition events | -| `rustfs_scanner_inline_heal_total` | counter | — | Objects queued for heal directly by the scanner | -| `rustfs_scanner_cache_save_duration_seconds` | histogram | `cache` | Time to persist the data-usage cache | -| `rustfs_scanner_set_scan_concurrency_limit` | gauge | — | Current per-set scan concurrency limit | -| `rustfs_scanner_disk_scan_concurrency_limit` | gauge | `pool`, `set` | Current per-disk scan concurrency limit | - -### Heal - -| Metric | Type | Labels | Meaning | +| `rustfs_scanner_objects_scanned_total` | counter | — | Vom Hintergrundscanner besuchte Objekte | +| `rustfs_scanner_directories_scanned_total` | counter | — | Besuchte Verzeichnisse | +| `rustfs_scanner_buckets_scanned_total` | counter | `result`, `bucket`, `disk` | Abgeschlossene Scans von Bucket und Laufwerk, nach Ergebnis (`success` / `error` / `partial`) | +| `rustfs_scanner_cycles_total` | counter | `result` | Abgeschlossene Scanner-Zyklen (`success` / `error` / `partial` / `unknown`) | +| `rustfs_scanner_cycle_duration_seconds` | gauge | — | Dauer des zuletzt abgeschlossenen Scan-Zyklus | +| `rustfs_scanner_bucket_drive_duration_seconds` | histogram | `bucket`, `disk` | Zeit, um einen Bucket auf einem Laufwerk zu scannen | +| `rustfs_scanner_leader_lock_total` | counter | `state` | Ereignisse zur Übernahme der Leader-Sperre des Scanners | +| `rustfs_scanner_inline_heal_total` | counter | — | Objekte, die der Scanner direkt zur Datenwiederherstellung einreiht | +| `rustfs_scanner_cache_save_duration_seconds` | histogram | `cache` | Zeit, um den Cache der Datennutzung zu persistieren | +| `rustfs_scanner_set_scan_concurrency_limit` | gauge | — | Aktuelle Grenze der Scan-Nebenläufigkeit je Set | +| `rustfs_scanner_disk_scan_concurrency_limit` | gauge | `pool`, `set` | Aktuelle Grenze der Scan-Nebenläufigkeit je Laufwerk | + +### Datenwiederherstellung + +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_heal_task_running` | gauge | `type`, `set` | Currently running heal tasks per erasure set | -| `rustfs_heal_task_start_total` | counter | `type`, `set` | Heal tasks started | -| `rustfs_heal_queue_delay_seconds` | histogram | `type`, `set` | Time a heal task waited in queue before starting | -| `rustfs_heal_admission_total` | counter | `source`, `result`, `reason`, `context` | Heal admission decisions (accepted / rejected and why) | -| `rustfs_heal_mainline_throttle_total` | counter | `source`, `result`, `reason` | Background heal throttled to protect foreground traffic | -| `rustfs_heal_scheduler_skip_total` | counter | `reason`, `set` | Heal scheduling skipped (e.g. per-set limit reached) | -| `rustfs_heal_page_concurrency_current` | gauge | — | Current page-level heal concurrency | -| `rustfs_heal_candidate_enqueue_total` | counter | — | Heal candidates enqueued by the scanner | -| `rustfs_heal_candidate_merge_total` | counter | — | Candidates merged with an existing queue entry | -| `rustfs_heal_candidate_drop_total` | counter | — | Candidates dropped | -| `rustfs_heal_candidate_priority_reject_total` | counter | — | Candidates rejected by priority policy | -| `rustfs_heal_read_repair_dedup_total` | counter | `reason` | Read-path repair requests deduplicated | - -### API / IO Path - -| Metric | Type | Labels | Meaning | +| `rustfs_heal_task_running` | gauge | `type`, `set` | Derzeit laufende Aufgaben der Datenwiederherstellung je Erasure-Set | +| `rustfs_heal_task_start_total` | counter | `type`, `set` | Gestartete Aufgaben der Datenwiederherstellung | +| `rustfs_heal_queue_delay_seconds` | histogram | `type`, `set` | Zeit, die eine Aufgabe der Datenwiederherstellung in der Warteschlange auf den Start gewartet hat | +| `rustfs_heal_admission_total` | counter | `source`, `result`, `reason`, `context` | Zulassungsentscheidungen der Datenwiederherstellung (angenommen oder abgelehnt, und warum) | +| `rustfs_heal_mainline_throttle_total` | counter | `source`, `result`, `reason` | Hintergrund-Datenwiederherstellung gedrosselt, um Vordergrundverkehr zu schützen | +| `rustfs_heal_scheduler_skip_total` | counter | `reason`, `set` | Planung der Datenwiederherstellung übersprungen (z. B. Grenze je Set erreicht) | +| `rustfs_heal_page_concurrency_current` | gauge | — | Aktuelle Nebenläufigkeit der Datenwiederherstellung auf Seitenebene | +| `rustfs_heal_candidate_enqueue_total` | counter | — | Vom Scanner eingereihte Kandidaten der Datenwiederherstellung | +| `rustfs_heal_candidate_merge_total` | counter | — | Kandidaten, die mit einem vorhandenen Warteschlangeneintrag zusammengeführt wurden | +| `rustfs_heal_candidate_drop_total` | counter | — | Verworfene Kandidaten | +| `rustfs_heal_candidate_priority_reject_total` | counter | — | Von der Prioritätsrichtlinie abgelehnte Kandidaten | +| `rustfs_heal_read_repair_dedup_total` | counter | `reason` | Deduplizierte Reparaturanforderungen des Lesepfads | + +### API- und E/A-Pfad + +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_io_get_object_request_duration_seconds` | histogram | `status` | End-to-end GetObject latency | -| `rustfs_io_get_object_stage_duration_seconds` | histogram | `path`, `stage` | GetObject latency broken down by internal stage | -| `rustfs_io_get_object_response_size_bytes` | histogram | — | GetObject response sizes | -| `rustfs_io_operation_duration_seconds` | histogram | `operation` | Duration of IO operations | -| `rustfs_io_timeout_events_total` | counter | `operation` | IO operations that hit a timeout | -| `rustfs_operation_progress` | gauge | `operation` | Progress percentage of long-running operations | -| `rustfs_operation_stalled` | counter | `operation` | Operations detected as stalled | -| `rustfs_operation_completions` | counter | `operation`, `status` | Operation completions by status | -| `rustfs_io_queue_operations` | counter | `operation`, `priority` | IO queue enqueue/dequeue operations | -| `rustfs_io_queue_size` | gauge | `priority` | Current IO queue depth per priority | -| `rustfs_io_starvation_events` | counter | `priority` | Low-priority IO starvation events | -| `rustfs_io_bandwidth_bps` | gauge | — | Observed IO bandwidth (bytes/s) | -| `rustfs_io_scheduler_decisions` | counter | — | IO scheduler decisions taken | -| `rustfs_io_scheduler_load` | counter | `level` | Scheduler decisions by load level | -| `rustfs_io_load_changes` | counter | `from`, `to` | IO load-level transitions | - -### Backpressure - -| Metric | Type | Labels | Meaning | +| `rustfs_io_get_object_request_duration_seconds` | histogram | `status` | Ende-zu-Ende-Latenz von GetObject | +| `rustfs_io_get_object_stage_duration_seconds` | histogram | `path`, `stage` | GetObject-Latenz, aufgeteilt nach interner Stufe | +| `rustfs_io_get_object_response_size_bytes` | histogram | — | Antwortgrößen von GetObject | +| `rustfs_io_operation_duration_seconds` | histogram | `operation` | Dauer von E/A-Operationen | +| `rustfs_io_timeout_events_total` | counter | `operation` | E/A-Operationen, die ein Zeitlimit erreicht haben | +| `rustfs_operation_progress` | gauge | `operation` | Fortschritt lang laufender Operationen in Prozent | +| `rustfs_operation_stalled` | counter | `operation` | Als stehen geblieben erkannte Operationen | +| `rustfs_operation_completions` | counter | `operation`, `status` | Abschlüsse von Operationen nach Status | +| `rustfs_io_queue_operations` | counter | `operation`, `priority` | Einreih- und Ausreihoperationen der E/A-Warteschlange | +| `rustfs_io_queue_size` | gauge | `priority` | Aktuelle Tiefe der E/A-Warteschlange je Priorität | +| `rustfs_io_starvation_events` | counter | `priority` | Aushungerungsereignisse von E/A mit niedriger Priorität | +| `rustfs_io_bandwidth_bps` | gauge | — | Beobachtete E/A-Bandbreite (Bytes/s) | +| `rustfs_io_scheduler_decisions` | counter | — | Getroffene Entscheidungen des E/A-Schedulers | +| `rustfs_io_scheduler_load` | counter | `level` | Scheduler-Entscheidungen nach Laststufe | +| `rustfs_io_load_changes` | counter | `from`, `to` | Übergänge der E/A-Laststufe | + +### Gegendruck + +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_backpressure_state_changes` | counter | `from`, `to` | Backpressure state transitions | -| `rustfs_backpressure_activations` | counter | — | Times backpressure engaged | -| `rustfs_backpressure_deactivations` | counter | — | Times backpressure released | -| `rustfs_backpressure_rejections` | counter | — | Requests rejected due to backpressure | -| `rustfs_backpressure_concurrent` | gauge | — | Current concurrent requests tracked by the limiter | +| `rustfs_backpressure_state_changes` | counter | `from`, `to` | Zustandsübergänge des Gegendrucks | +| `rustfs_backpressure_activations` | counter | — | Wie oft der Gegendruck gegriffen hat | +| `rustfs_backpressure_deactivations` | counter | — | Wie oft der Gegendruck gelöst wurde | +| `rustfs_backpressure_rejections` | counter | — | Wegen Gegendruck abgelehnte Anfragen | +| `rustfs_backpressure_concurrent` | gauge | — | Aktuelle gleichzeitige Anfragen, die der Begrenzer führt | -### Capacity +### Kapazität -| Metric | Type | Labels | Meaning | +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_capacity_current_bytes` | gauge | — | Current used capacity in bytes | -| `rustfs_capacity_update_total` | counter | `source` | Capacity recalculations | -| `rustfs_capacity_update_duration_seconds` | histogram | `source` | Time to recalculate capacity | -| `rustfs_capacity_cache_hits` | counter | — | Capacity cache hits | -| `rustfs_capacity_cache_misses` | counter | — | Capacity cache misses | -| `rustfs_capacity_cache_served_total` | counter | `state` | Capacity responses served from cache, by freshness state | +| `rustfs_capacity_current_bytes` | gauge | — | Aktuell genutzte Kapazität in Bytes | +| `rustfs_capacity_update_total` | counter | `source` | Neuberechnungen der Kapazität | +| `rustfs_capacity_update_duration_seconds` | histogram | `source` | Zeit für die Neuberechnung der Kapazität | +| `rustfs_capacity_cache_hits` | counter | — | Treffer im Kapazitätscache | +| `rustfs_capacity_cache_misses` | counter | — | Fehltreffer im Kapazitätscache | +| `rustfs_capacity_cache_served_total` | counter | `state` | Aus dem Cache bediente Kapazitätsantworten, nach Frischezustand | -### Locking +### Sperren -| Metric | Type | Labels | Meaning | +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_lock_contentions` | counter | — | Lock contention events | -| `rustfs_lock_hold_time_secs` | histogram | — | How long locks were held | -| `rustfs_lock_spin_successes` / `rustfs_lock_spin_failures` | counter | — | Spin-lock acquisition outcomes | -| `rustfs_lock_early_releases` | counter | — | Locks released early by optimization | -| `rustfs_object_lock_diag_acquire_duration_seconds` | histogram | — | Object-lock acquire latency (diagnostics mode) | -| `rustfs_object_lock_diag_hold_duration_seconds` | histogram | — | Object-lock hold duration (diagnostics mode) | -| `rustfs_object_lock_diag_slow_acquire_total` / `rustfs_object_lock_diag_slow_hold_total` | counter | — | Slow lock acquire/hold events (diagnostics mode) | +| `rustfs_lock_contentions` | counter | — | Ereignisse von Sperrkonkurrenz | +| `rustfs_lock_hold_time_secs` | histogram | — | Wie lange Sperren gehalten wurden | +| `rustfs_lock_spin_successes` / `rustfs_lock_spin_failures` | counter | — | Ergebnisse der Übernahme von Spin-Locks | +| `rustfs_lock_early_releases` | counter | — | Durch Optimierung vorzeitig freigegebene Sperren | +| `rustfs_object_lock_diag_acquire_duration_seconds` | histogram | — | Latenz der Übernahme der Objektsperre (Diagnosemodus) | +| `rustfs_object_lock_diag_hold_duration_seconds` | histogram | — | Haltedauer der Objektsperre (Diagnosemodus) | +| `rustfs_object_lock_diag_slow_acquire_total` / `rustfs_object_lock_diag_slow_hold_total` | counter | — | Langsame Übernahme oder langes Halten einer Sperre (Diagnosemodus) | -### Log Cleaner +### Protokollbereinigung -| Metric | Type | Labels | Meaning | +| Metrik | Typ | Labels | Bedeutung | | --- | --- | --- | --- | -| `rustfs_log_cleaner_runs_total` | counter | — | Log-cleaner runs | -| `rustfs_log_cleaner_deleted_files_total` | counter | — | Log files deleted | -| `rustfs_log_cleaner_freed_bytes_total` | counter | — | Bytes reclaimed | -| `rustfs_log_cleaner_rotation_total` / `rustfs_log_cleaner_rotation_failures_total` | counter | — | Log rotations and rotation failures | -| `rustfs_log_cleaner_rotation_duration_seconds` | histogram | — | Rotation duration | -| `rustfs_log_cleaner_active_file_size_bytes` | gauge | — | Size of the active log file | +| `rustfs_log_cleaner_runs_total` | counter | — | Läufe der Protokollbereinigung | +| `rustfs_log_cleaner_deleted_files_total` | counter | — | Gelöschte Protokolldateien | +| `rustfs_log_cleaner_freed_bytes_total` | counter | — | Zurückgewonnene Bytes | +| `rustfs_log_cleaner_rotation_total` / `rustfs_log_cleaner_rotation_failures_total` | counter | — | Protokollrotationen und Rotationsfehler | +| `rustfs_log_cleaner_rotation_duration_seconds` | histogram | — | Dauer der Rotation | +| `rustfs_log_cleaner_active_file_size_bytes` | gauge | — | Größe der aktiven Protokolldatei | -:::note[Additional metrics] +:::note[Weitere Metriken] -Additional verified metric names exist whose type/label details are not documented here, including `rustfs_scanner_cache_save_attempt_total`, `rustfs_scanner_cache_save_timeout_total`, `rustfs_scanner_cache_save_retry_total`, `rustfs_scanner_excess_object_versions_total`, `rustfs_scanner_excess_object_version_size_total`, `rustfs_scanner_excess_folders_total`, `rustfs_scanner_pending_heal_prune_total`, `rustfs_scanner_pending_heal_malformed_total`, and the `rustfs_io_scheduler_*` / `rustfs_io_buffer_*` / `rustfs_timeout_dynamic_*` families. Inspect them in Prometheus once the pipeline is live. +Weitere geprüfte Metriknamen existieren, deren Typ- und Label-Details hier nicht dokumentiert sind, darunter `rustfs_scanner_cache_save_attempt_total`, `rustfs_scanner_cache_save_timeout_total`, `rustfs_scanner_cache_save_retry_total`, `rustfs_scanner_excess_object_versions_total`, `rustfs_scanner_excess_object_version_size_total`, `rustfs_scanner_excess_folders_total`, `rustfs_scanner_pending_heal_prune_total`, `rustfs_scanner_pending_heal_malformed_total` sowie die Familien `rustfs_io_scheduler_*`, `rustfs_io_buffer_*` und `rustfs_timeout_dynamic_*`. Sehen Sie sie in Prometheus ein, sobald die Pipeline läuft. ::: -## Suggested Alerts +## Empfohlene Alarme -| Alert | Signal | Suggested rule | +| Alarm | Signal | Empfohlene Regel | | --- | --- | --- | -| Node not ready > 2 min | `rustfs_runtime_readiness_ready` gauge, or an external probe on `GET /health/ready` returning non-200 | `rustfs_runtime_readiness_ready == 0` for `2m` | -| Restart loop | `rustfs_start_total` | `increase(rustfs_start_total[10m]) > 3` | -| Heal backlog growing | `rustfs_heal_task_running` and `rustfs_heal_queue_delay_seconds` | sustained non-zero running tasks plus rising queue delay for `30m` | -| Scanner stalled | `rustfs_scanner_cycles_total` | `increase(rustfs_scanner_cycles_total[24h]) == 0` | -| Cluster used capacity watermark | `rustfs_capacity_current_bytes` | compare against your deployed raw capacity (a constant you set), e.g. `rustfs_capacity_current_bytes > 0.8 * ` | +| Knoten länger als 2 Minuten nicht bereit | Gauge `rustfs_runtime_readiness_ready` oder eine externe Prüfung von `GET /health/ready`, die nicht 200 liefert | `rustfs_runtime_readiness_ready == 0` für `2m` | +| Neustartschleife | `rustfs_start_total` | `increase(rustfs_start_total[10m]) > 3` | +| Wachsender Rückstand der Datenwiederherstellung | `rustfs_heal_task_running` und `rustfs_heal_queue_delay_seconds` | anhaltend von null verschiedene laufende Aufgaben plus steigende Warteschlangenverzögerung für `30m` | +| Scanner steht still | `rustfs_scanner_cycles_total` | `increase(rustfs_scanner_cycles_total[24h]) == 0` | +| Schwellenwert der genutzten Clusterkapazität | `rustfs_capacity_current_bytes` | Vergleich mit Ihrer bereitgestellten Rohkapazität (eine Konstante, die Sie setzen), z. B. `rustfs_capacity_current_bytes > 0.8 * ` | :::note -Per-disk usage and disk online/offline state are currently surfaced through the console and the admin API (server/storage info), not as dedicated OTLP metrics. For a per-disk watermark alert, poll the admin API from your own exporter or watch the console dashboard. +Die Nutzung je Laufwerk und der Online- oder Offline-Zustand eines Laufwerks erscheinen derzeit über die Console und die Admin-API (Server- und Speicherinformationen), nicht als eigene OTLP-Metriken. Für einen Alarm zum Schwellenwert je Laufwerk fragen Sie die Admin-API aus Ihrem eigenen Exporter ab oder beobachten Sie das Dashboard der Console. ::: -## Log Collection +## Protokollerfassung -Where logs go is controlled by `RUSTFS_OBS_LOG_DIRECTORY`: +Wohin Protokolle gehen, steuert `RUSTFS_OBS_LOG_DIRECTORY`: -- **Unset** — logs go to stdout. In containers, use your log driver; on systemd hosts, stdout/stderr is captured by **journald**, so `journalctl -u rustfs -f` works without extra configuration. -- **A local directory** (e.g. `/var/log/rustfs/`) — RustFS writes rotating log files there. Rotation is tuned with `RUSTFS_OBS_LOG_FILENAME`, `RUSTFS_OBS_LOG_ROTATION_SIZE_MB`, `RUSTFS_OBS_LOG_ROTATION_TIME`, and `RUSTFS_OBS_LOG_KEEP_FILES`. -- **A URL** (contains `://`) — logs are shipped to a remote endpoint. +- **Nicht gesetzt:** Protokolle gehen nach stdout. Verwenden Sie in Containern Ihren Log-Treiber. Auf systemd-Hosts erfasst **journald** stdout und stderr, deshalb funktioniert `journalctl -u rustfs -f` ohne weitere Konfiguration. +- **Ein lokales Verzeichnis** (z. B. `/var/log/rustfs/`): RustFS schreibt dort rotierende Protokolldateien. Die Rotation stellen Sie mit `RUSTFS_OBS_LOG_FILENAME`, `RUSTFS_OBS_LOG_ROTATION_SIZE_MB`, `RUSTFS_OBS_LOG_ROTATION_TIME` und `RUSTFS_OBS_LOG_KEEP_FILES` ein. +- **Eine URL** (enthält `://`): Protokolle werden an einen entfernten Endpunkt geliefert. -When `RUSTFS_OBS_ENDPOINT` is set and log export is enabled, logs are additionally exported via OTLP; the reference stack routes them into Loki for querying from Grafana. +Wenn `RUSTFS_OBS_ENDPOINT` gesetzt ist und der Protokollexport aktiviert ist, werden Protokolle zusätzlich über OTLP exportiert. Der Referenzstapel leitet sie zur Abfrage aus Grafana nach Loki. ```bash title="Example: file logs plus OTLP export" RUSTFS_ADDRESS=":9000" diff --git a/content/de/operations/rc.mdx b/content/de/operations/rc.mdx index 5339949e8..d5ca3148c 100644 --- a/content/de/operations/rc.mdx +++ b/content/de/operations/rc.mdx @@ -1,20 +1,20 @@ --- -title: "CLI Client (rc)" -description: "Install the RustFS command-line client and use it to connect to and inspect a RustFS cluster." +title: "CLI-Client (rc)" +description: "Installieren Sie den RustFS-Kommandozeilenclient und nutzen Sie ihn, um eine Verbindung zu einem RustFS-Cluster herzustellen und den Cluster einzusehen." --- -`rc` is the RustFS command-line client for S3 object operations and RustFS administration. This guide installs `rc`, configures a cluster alias, and introduces the main inspection commands. The download examples use `v0.1.30`; check the [RustFS CLI releases](https://github.com/rustfs/cli/releases) for a newer version before installing. +`rc` ist der RustFS-Kommandozeilenclient für S3-Objektoperationen und die RustFS-Verwaltung. In dieser Anleitung installieren Sie `rc`, konfigurieren einen Cluster-Alias und lernen die wichtigsten Befehle zur Einsicht kennen. Die Download-Beispiele verwenden `v0.1.30`. Prüfen Sie vor der Installation die [RustFS-CLI-Releases](https://github.com/rustfs/cli/releases) auf eine neuere Version. ## Installation ### Linux -The default Linux archives are statically linked with musl for broad compatibility. Choose the tab that matches `uname -m`. +Die Standardarchive für Linux sind für eine breite Kompatibilität statisch mit musl gelinkt. Wählen Sie die Registerkarte, die zu `uname -m` passt. -For an `x86_64` host: +Für einen Host mit `x86_64`: ```bash curl -fLO https://github.com/rustfs/cli/releases/download/v0.1.30/rustfs-cli-linux-amd64-v0.1.30.tar.gz @@ -25,7 +25,7 @@ sudo install -m 0755 rc /usr/local/bin/rc -For an `aarch64` host: +Für einen Host mit `aarch64`: ```bash curl -fLO https://github.com/rustfs/cli/releases/download/v0.1.30/rustfs-cli-linux-arm64-v0.1.30.tar.gz @@ -36,16 +36,16 @@ sudo install -m 0755 rc /usr/local/bin/rc -If your environment specifically requires a glibc-linked binary, select the `linux-amd64-gnu` or `linux-arm64-gnu` archive from the release page. +Wenn Ihre Umgebung ausdrücklich eine mit glibc gelinkte Binärdatei benötigt, wählen Sie auf der Release-Seite das Archiv `linux-amd64-gnu` oder `linux-arm64-gnu`. ### macOS -Choose the tab that matches the value returned by `uname -m`. +Wählen Sie die Registerkarte, die zum Wert von `uname -m` passt. -For an Intel (`x86_64`) Mac: +Für einen Intel-Mac (`x86_64`): ```bash curl -fLO https://github.com/rustfs/cli/releases/download/v0.1.30/rustfs-cli-macos-amd64-v0.1.30.tar.gz @@ -56,7 +56,7 @@ sudo install -m 0755 rc /usr/local/bin/rc -For an Apple silicon (`arm64`) Mac: +Für einen Mac mit Apple Silicon (`arm64`): ```bash curl -fLO https://github.com/rustfs/cli/releases/download/v0.1.30/rustfs-cli-macos-arm64-v0.1.30.tar.gz @@ -67,7 +67,7 @@ sudo install -m 0755 rc /usr/local/bin/rc -You can alternatively install the package through Homebrew: +Sie können das Paket alternativ über Homebrew installieren: ```bash brew install rustfs/tap/rc @@ -75,63 +75,63 @@ brew install rustfs/tap/rc ### Windows -The current Windows release provides an AMD64 binary. Install it through the official Scoop bucket: +Die aktuelle Windows-Version stellt eine AMD64-Binärdatei bereit. Installieren Sie sie über den offiziellen Scoop-Bucket: ```powershell scoop bucket add rustfs https://github.com/rustfs/scoop-bucket scoop install rustfs/rc ``` -### Verify the installation +### Installation prüfen -Open a new terminal and verify that `rc` is available: +Öffnen Sie ein neues Terminal und prüfen Sie, ob `rc` verfügbar ist: ```bash rc --version rc --help ``` -## Usage +## Verwendung -### Configure an alias +### Alias konfigurieren -An alias stores the RustFS endpoint and credentials so you do not need to repeat them for every command. Replace the credentials before running: +Ein Alias speichert den RustFS-Endpunkt und die Zugangsdaten, damit Sie sie nicht bei jedem Befehl wiederholen müssen. Ersetzen Sie die Zugangsdaten, bevor Sie den Befehl ausführen: ```bash rc alias set local http://localhost:9000 rc alias list ``` -`alias set` replaces an existing alias with the same name. `alias list` does not print secret keys. +`alias set` ersetzt einen vorhandenen Alias mit demselben Namen. `alias list` gibt geheime Zugriffsschlüssel nicht aus. -### Check service health +### Integrität des Dienstes prüfen -Check whether the service is live and whether its required dependencies are ready: +Prüfen Sie, ob der Dienst läuft und ob die erforderlichen Abhängigkeiten bereit sind: ```bash rc ping local rc ready local ``` -### Inspect the cluster +### Cluster einsehen -Use the administrative cluster information command to inspect cluster status, servers, disks, and storage capacity: +Nutzen Sie den administrativen Befehl für Clusterinformationen, um Clusterstatus, Server, Laufwerke und Speicherkapazität einzusehen: ```bash rc admin info cluster local ``` -List server pools when the deployment uses multiple pools: +Listen Sie die Serverpools auf, wenn die Bereitstellung mehrere Speicherpools verwendet: ```bash rc admin pool list local ``` -Administrative commands require credentials with the corresponding RustFS Admin API permissions. +Administrative Befehle erfordern Zugangsdaten mit den entsprechenden Berechtigungen der RustFS Admin API. -### Inspect buckets and objects +### Buckets und Objekte einsehen -Prefer the noun-first command groups for new scripts: +Bevorzugen Sie für neue Skripte die Befehlsgruppen, die mit dem Substantiv beginnen: ```bash rc bucket list local/ @@ -139,9 +139,9 @@ rc object list local/my-bucket rc object stat local/my-bucket/hello.txt ``` -### Manage lifecycle rules and storage tiers +### Lebenszyklusregeln und Speicherstufen verwalten -`rc` groups lifecycle rules, remote storage tiers, and restore requests under `bucket lifecycle`: +`rc` fasst Lebenszyklusregeln, entfernte Speicherstufen und Wiederherstellungsanforderungen unter `bucket lifecycle` zusammen: ```bash rc bucket lifecycle rule list local/my-bucket @@ -149,13 +149,13 @@ rc bucket lifecycle tier list local rc bucket lifecycle restore local/my-bucket/hello.txt --days 7 ``` -Use the `rule` commands to add, edit, remove, export, or import bucket lifecycle rules. Use the `tier` commands to add, inspect, update credentials for, or remove a remote tier. The older `rc ilm` form remains available as a compatibility alias, but we recommend `rc bucket lifecycle` for new scripts. +Mit den `rule`-Befehlen fügen Sie Bucket-Lebenszyklusregeln hinzu, bearbeiten, entfernen, exportieren oder importieren sie. Mit den `tier`-Befehlen fügen Sie eine entfernte Stufe hinzu, lesen sie aus, aktualisieren ihre Zugangsdaten oder entfernen sie. Die ältere Form `rc ilm` bleibt als Kompatibilitätsalias verfügbar. Wir empfehlen für neue Skripte `rc bucket lifecycle`. -See [Lifecycle Management](/administration/data/lifecycle-management) for rule and restore workflows, and [Tiered Storage](/administration/data/tiered-storage) for remote-tier configuration and maintenance. +Siehe [Lebenszyklusverwaltung](/de/administration/data/lifecycle-management) für Abläufe zu Regeln und Wiederherstellung und [Gestufte Speicherung](/de/administration/data/tiered-storage) für Konfiguration und Wartung entfernter Stufen. -### Discover more commands +### Weitere Befehle anzeigen -Use `--help` at any command level to see the commands and options supported by your installed version: +Verwenden Sie `--help` auf jeder Befehlsebene, um die Befehle und Optionen Ihrer installierten Version anzuzeigen: ```bash rc --help @@ -167,4 +167,4 @@ rc bucket lifecycle --help rc object --help ``` -For the complete source and command reference, see the [RustFS CLI repository](https://github.com/rustfs/cli). +Den vollständigen Quellcode und die Befehlsreferenz finden Sie im [RustFS-CLI-Repository](https://github.com/rustfs/cli). diff --git a/content/de/operations/scaling/data-rebalancing.md b/content/de/operations/scaling/data-rebalancing.md index 5025f8540..dd3bf605b 100644 --- a/content/de/operations/scaling/data-rebalancing.md +++ b/content/de/operations/scaling/data-rebalancing.md @@ -1,84 +1,84 @@ --- title: "Rebalancing" -description: "Redistribute existing objects across active RustFS storage pools through the Console or rc." +description: "Verteilen Sie vorhandene Objekte über aktive RustFS-Speicherpools neu, über die Console oder mit rc." --- -## Overview +## Überblick -### Requirements +### Voraussetzungen -- Install [`rc`](/operations/rc) on the administration host before using the `rc` workflow in this guide. -- Configure credentials with rebalance administration permission. +- Installieren Sie [`rc`](/de/operations/rc) auf dem Administrationshost, bevor Sie den `rc`-Ablauf in dieser Anleitung verwenden. +- Konfigurieren Sie Zugangsdaten mit der Berechtigung zur Rebalancing-Verwaltung. -After [Pool Expansion](./storage-pool-expansion.md), new writes can use the added capacity, but existing objects remain in their original pools. **Rebalancing** moves existing objects across all active pools so their used-capacity ratios converge. +Nach der [Speicherpool-Erweiterung](./storage-pool-expansion.md) können neue Schreibvorgänge die zusätzliche Kapazität nutzen. Vorhandene Objekte bleiben in ihren ursprünglichen Speicherpools. **Rebalancing** verschiebt vorhandene Objekte über alle aktiven Speicherpools, sodass sich die Verhältnisse der genutzten Kapazität angleichen. -Rebalancing requires at least two active pools. RustFS rejects a new rebalance while another rebalance or a pool decommission is running. Stopping a rebalance does not move already relocated objects back to their original pools. +Rebalancing erfordert mindestens zwei aktive Speicherpools. RustFS lehnt ein neues Rebalancing ab, solange ein anderes Rebalancing oder eine Speicherpool-Außerbetriebnahme läuft. Wenn Sie ein Rebalancing stoppen, werden bereits verlagerte Objekte nicht in ihre ursprünglichen Speicherpools zurückverschoben. -Before starting, verify that all nodes and disks are healthy, no decommission is active, and the cluster has enough free capacity for normal writes during the operation. Schedule the operation during a lower-traffic period because object movement consumes disk, network, and CPU resources. +Prüfen Sie vor dem Start, dass alle Knoten und Laufwerke betriebsbereit sind, keine Außerbetriebnahme aktiv ist und der Cluster während des Vorgangs genug freie Kapazität für normale Schreibvorgänge hat. Planen Sie den Vorgang in eine Zeit mit geringerer Last, weil die Objektverschiebung Laufwerks-, Netzwerk- und CPU-Ressourcen verbraucht. -## Operation +## Ablauf -### Start rebalancing in the Console +### Rebalancing in der Console starten -1. Sign in to the RustFS Console with an account that has rebalance administration permission. -2. Open **Rebalance**. -3. Review the active pools and their used-capacity ratios. -4. Select **Start Rebalance** and confirm the operation. -5. Keep the page open or return to it periodically to review per-pool progress. -6. Use **Stop Rebalance** only when you need to halt the operation. Data already moved remains in its new pool. +1. Melden Sie sich an der RustFS Console (Weboberfläche) mit einem Konto an, das die Berechtigung zur Rebalancing-Verwaltung hat. +2. Öffnen Sie **Rebalance** (Rebalancing). +3. Prüfen Sie die aktiven Speicherpools und die Verhältnisse der genutzten Kapazität. +4. Wählen Sie **Start Rebalance** (Rebalancing starten) und bestätigen Sie den Vorgang. +5. Lassen Sie die Seite geöffnet oder kehren Sie regelmäßig dorthin zurück, um den Fortschritt je Speicherpool zu prüfen. +6. Verwenden Sie **Stop Rebalance** (Rebalancing stoppen) nur, wenn Sie den Vorgang anhalten müssen. Bereits verschobene Daten bleiben im neuen Speicherpool. -![RustFS Console showing a rebalance in progress with moved bytes and objects](./images/rebalance-running-console.png) +![RustFS Console mit laufendem Rebalancing, verschobenen Bytes und Objekten](./images/rebalance-running-console.png) -### Start rebalancing with rc +### Rebalancing mit rc starten -Configure the cluster alias if it does not already exist: +Konfigurieren Sie den Cluster-Alias, falls er noch nicht existiert: ```bash rc alias set rustfs http://:9000 ``` -Start the rebalance: +Starten Sie das Rebalancing: ```bash rc admin rebalance start rustfs ``` -Check progress: +Prüfen Sie den Fortschritt: ```bash rc admin rebalance status rustfs ``` -The status includes the operation ID and per-pool usage, moved bytes, object and version counts, remaining buckets, elapsed time, and estimated completion time when available. +Der Status enthält die Vorgangs-ID sowie je Speicherpool die Nutzung, verschobene Bytes, Objekt- und Versionszahlen, verbleibende Buckets, die vergangene Zeit und, falls verfügbar, die geschätzte Abschlusszeit. -To stop a running rebalance: +So stoppen Sie ein laufendes Rebalancing: ```bash rc admin rebalance stop rustfs ``` -`rc admin expand start|status|stop` and the `scale` alias expose the same post-expansion rebalance workflow. +`rc admin expand start|status|stop` und der Alias `scale` stellen denselben Rebalancing-Ablauf nach einer Erweiterung bereit. -## Verification +## Überprüfung -### Verify rebalancing in the Console +### Rebalancing in der Console prüfen -Wait until the Rebalance page reports `Completed`. Confirm that: +Warten Sie, bis die Seite **Rebalance** den Status `Completed` meldet. Bestätigen Sie Folgendes: -![RustFS Console showing a completed rebalance and balanced pool usage](./images/rebalance-completed-console.png) +![RustFS Console mit abgeschlossenem Rebalancing und ausgeglichener Speichernutzung der Speicherpools](./images/rebalance-completed-console.png) -- No pool reports a failed or stopped state. -- Used-capacity ratios are closer across the active pools. -- All nodes and disks remain online. -- Normal object reads and writes succeed. +- Kein Speicherpool meldet einen fehlgeschlagenen oder gestoppten Zustand. +- Die Verhältnisse der genutzten Kapazität liegen über die aktiven Speicherpools hinweg näher beieinander. +- Alle Knoten und Laufwerke bleiben online. +- Normale Lese- und Schreibvorgänge für Objekte gelingen. -### Verify rebalancing with rc +### Rebalancing mit rc prüfen -Run: +Führen Sie aus: ```bash rc admin rebalance status rustfs rc admin pool list rustfs ``` -Verify that the rebalance status is `Completed`, remaining bucket counts are zero, and no failure is reported. Compare the per-pool usage ratios with the values recorded before the operation, then read an existing object and write a new test object through the S3 endpoint. +Prüfen Sie, dass der Rebalancing-Status `Completed` ist, die Zahl der verbleibenden Buckets null ist und kein Fehler gemeldet wird. Vergleichen Sie die Nutzungsverhältnisse je Speicherpool mit den vor dem Vorgang notierten Werten. Lesen Sie anschließend ein vorhandenes Objekt und schreiben Sie ein neues Testobjekt über den S3-Endpunkt. diff --git a/content/de/operations/scaling/index.md b/content/de/operations/scaling/index.md index ffa659899..cfa7b2277 100644 --- a/content/de/operations/scaling/index.md +++ b/content/de/operations/scaling/index.md @@ -1,10 +1,10 @@ --- -title: "Scaling" -description: "Expand, rebalance, and retire RustFS storage pools." +title: "Skalierung" +description: "Erweitern Sie RustFS-Speicherpools, führen Sie ein Rebalancing aus und nehmen Sie Speicherpools außer Betrieb." --- -Choose the workflow that matches the topology change: +Wählen Sie den Ablauf, der zur Topologieänderung passt: -- [Pool Expansion](./storage-pool-expansion.md) +- [Speicherpool-Erweiterung](./storage-pool-expansion.md) - [Rebalancing](./data-rebalancing.md) -- [Pool Decommission](./storage-pool-decommission.md) \ No newline at end of file +- [Speicherpool-Außerbetriebnahme](./storage-pool-decommission.md) diff --git a/content/de/operations/scaling/storage-pool-decommission.md b/content/de/operations/scaling/storage-pool-decommission.md index 4b881793f..9c205a248 100644 --- a/content/de/operations/scaling/storage-pool-decommission.md +++ b/content/de/operations/scaling/storage-pool-decommission.md @@ -1,119 +1,119 @@ --- -title: "Pool Decommission" -description: "Drain and retire a RustFS storage pool through the Console or rc, then verify that its data was relocated." +title: "Speicherpool-Außerbetriebnahme" +description: "Leeren Sie einen RustFS-Speicherpool über die Console oder mit rc, nehmen Sie ihn außer Betrieb und prüfen Sie, dass seine Daten verlagert wurden." --- -## Overview +## Überblick -### Requirements +### Voraussetzungen -- Install [`rc`](/operations/rc) on the administration host before using the `rc` workflow in this guide. -- Configure credentials with decommission administration permission. +- Installieren Sie [`rc`](/de/operations/rc) auf dem Administrationshost, bevor Sie den `rc`-Ablauf in dieser Anleitung verwenden. +- Konfigurieren Sie Zugangsdaten mit der Berechtigung zur Verwaltung der Außerbetriebnahme. -**Pool decommission** moves objects from a selected pool to the remaining active pools so the target pool can be removed from the deployment. Use it when retiring hardware, replacing a pool, or consolidating capacity. +Die **Speicherpool-Außerbetriebnahme** verschiebt Objekte aus einem ausgewählten Speicherpool in die verbleibenden aktiven Speicherpools, damit der Zielpool aus der Bereitstellung entfernt werden kann. Nutzen Sie sie, wenn Sie Hardware außer Betrieb nehmen, einen Speicherpool ersetzen oder Kapazität zusammenführen. -Decommission is different from [Rebalancing](./data-rebalancing.md): rebalance keeps every pool active, while decommission drains and retires the selected pool. The two operations cannot run at the same time. +Die Außerbetriebnahme unterscheidet sich vom [Rebalancing](./data-rebalancing.md): Beim Rebalancing bleibt jeder Speicherpool aktiv, bei der Außerbetriebnahme wird der ausgewählte Speicherpool geleert und stillgelegt. Die beiden Vorgänge können nicht gleichzeitig laufen. -Before starting: +Vor dem Start: -- Keep at least one active pool after the operation. -- Verify that the remaining pools have enough free capacity. RustFS requires their free space to cover the used bytes being drained plus a 30% overhead. -- Confirm that every node and disk is healthy and no rebalance is running. -- Back up critical data and schedule the operation during a lower-traffic period. -- Record the exact pool ID and volume expression before selecting the target. +- Es muss nach dem Vorgang mindestens ein aktiver Speicherpool bleiben. +- Prüfen Sie, dass die verbleibenden Speicherpools genug freie Kapazität haben. RustFS verlangt, dass ihr freier Speicher die abfließenden genutzten Bytes plus 30 % Aufschlag deckt. +- Bestätigen Sie, dass jeder Knoten und jedes Laufwerk betriebsbereit ist und kein Rebalancing läuft. +- Sichern Sie kritische Daten und planen Sie den Vorgang in eine Zeit mit geringerer Last. +- Notieren Sie die genaue Pool-ID und den Volume-Ausdruck, bevor Sie das Ziel auswählen. -Canceling a decommission does not roll back completed moves. Objects already relocated remain in the destination pools. +Wenn Sie eine Außerbetriebnahme abbrechen, werden abgeschlossene Verschiebungen nicht zurückgerollt. Bereits verlagerte Objekte bleiben in den Zielpools. -## Operation +## Ablauf -### Start decommissioning in the Console +### Außerbetriebnahme in der Console starten -1. Sign in to the RustFS Console with an account that has decommission administration permission. -2. Open **Pool Decommission**. -3. Locate the pool to retire and verify its ID, volume expression, used capacity, and status. +1. Melden Sie sich an der RustFS Console (Weboberfläche) mit einem Konto an, das die Berechtigung zur Verwaltung der Außerbetriebnahme hat. +2. Öffnen Sie **Pool Decommission** (Speicherpool-Außerbetriebnahme). +3. Suchen Sie den stillzulegenden Speicherpool und prüfen Sie ID, Volume-Ausdruck, genutzte Kapazität und Status. - ![RustFS Console showing the selected storage pool before decommissioning](./images/pool-decommission-selection-console.png) + ![RustFS Console mit dem ausgewählten Speicherpool vor der Außerbetriebnahme](./images/pool-decommission-selection-console.png) -4. Select **Start Decommission** for that pool. -5. Review the confirmation dialog carefully, then select **Start Decommission**. +4. Wählen Sie **Start Decommission** (Außerbetriebnahme starten) für diesen Speicherpool. +5. Prüfen Sie den Bestätigungsdialog sorgfältig und wählen Sie dann erneut **Start Decommission**. - ![RustFS Console showing the pool decommission confirmation dialog](./images/pool-decommission-confirmation-console.png) + ![RustFS Console mit dem Bestätigungsdialog der Speicherpool-Außerbetriebnahme](./images/pool-decommission-confirmation-console.png) -6. Use **Sync** to refresh the pool state and movement counters until the operation completes. +6. Nutzen Sie **Sync** (Synchronisieren), um den Poolzustand und die Verschiebezähler zu aktualisieren, bis der Vorgang abgeschlossen ist. - ![RustFS Console showing pool decommission progress and movement counters](./images/pool-decommission-running-console.png) + ![RustFS Console mit dem Fortschritt der Außerbetriebnahme und den Verschiebezählern](./images/pool-decommission-running-console.png) -After completion, remove the drained pool expression from `RUSTFS_VOLUMES` on every remaining node and restart RustFS with the same ordered topology. For Helm, decommission the pool before removing its entry from `pools.list`; never remove or reorder a live pool entry. +Entfernen Sie nach dem Abschluss den Ausdruck des geleerten Speicherpools auf jedem verbleibenden Knoten aus `RUSTFS_VOLUMES` und starten Sie RustFS mit derselben geordneten Topologie neu. Nehmen Sie den Speicherpool bei Helm außer Betrieb, bevor Sie seinen Eintrag aus `pools.list` entfernen. Entfernen Sie einen aktiven Pool-Eintrag niemals und ändern Sie seine Reihenfolge nicht. -![RustFS Console showing the selected pool with a completed decommission status](./images/pool-decommission-completed-console.png) +![RustFS Console mit abgeschlossenem Status der Außerbetriebnahme für den ausgewählten Speicherpool](./images/pool-decommission-completed-console.png) -### Start decommissioning with rc +### Außerbetriebnahme mit rc starten -Configure the cluster alias if needed, then list the pools: +Konfigurieren Sie bei Bedarf den Cluster-Alias und listen Sie dann die Speicherpools auf: ```bash rc alias set rustfs http://:9000 rc admin pool list rustfs ``` -Start decommissioning pool `0` by its zero-based ID: +Starten Sie die Außerbetriebnahme von Pool `0` über seine nullbasierte ID: ```bash rc admin decommission start rustfs 0 --by-id ``` -You can instead pass the exact pool volume expression without `--by-id`: +Sie können stattdessen den genauen Volume-Ausdruck des Speicherpools ohne `--by-id` übergeben: ```bash rc admin decommission start rustfs 'http://rustfs-node1:9000/data/rustfs{1...4}/mnmd' ``` -Monitor all pools or only the target pool: +Beobachten Sie alle Speicherpools oder nur den Zielpool: ```bash rc admin decommission status rustfs rc admin decommission status rustfs 0 --by-id ``` -To cancel a running operation, use: +So brechen Sie einen laufenden Vorgang ab: ```bash rc admin decommission cancel rustfs 0 --by-id ``` -If a decommission is failed or canceled, clear its metadata before retrying: +Wenn eine Außerbetriebnahme fehlgeschlagen ist oder abgebrochen wurde, löschen Sie ihre Metadaten, bevor Sie es erneut versuchen: ```bash rc admin decommission clear rustfs 0 --by-id ``` -After the target reports `complete`, remove its expression from `RUSTFS_VOLUMES` on every remaining node and restart RustFS with the reduced topology. +Nachdem das Ziel `complete` meldet, entfernen Sie seinen Ausdruck auf jedem verbleibenden Knoten aus `RUSTFS_VOLUMES` und starten Sie RustFS mit der reduzierten Topologie neu. -## Verification +## Überprüfung -### Verify decommissioning in the Console +### Außerbetriebnahme in der Console prüfen -Confirm that the target pool reports `Completed`, with zero failed objects and zero failed bytes. After removing the pool from the startup topology and restarting RustFS, verify that: +Bestätigen Sie, dass der Zielpool `Completed` meldet, mit null fehlgeschlagenen Objekten und null fehlgeschlagenen Bytes. Prüfen Sie nach dem Entfernen des Speicherpools aus der Starttopologie und dem Neustart von RustFS Folgendes: -![RustFS Console showing only the remaining pool after the retired pool was removed](./images/pool-decommission-final-topology-console.png) +![RustFS Console, die nach dem Entfernen des stillgelegten Speicherpools nur den verbleibenden Speicherpool zeigt](./images/pool-decommission-final-topology-console.png) -- The retired pool no longer appears as an active pool. -- Every remaining node and disk is online. -- Remaining pools show the relocated data and have adequate free capacity. -- Existing objects can still be listed, read, and downloaded. +- Der stillgelegte Speicherpool erscheint nicht mehr als aktiver Speicherpool. +- Jeder verbleibende Knoten und jedes verbleibende Laufwerk ist online. +- Die verbleibenden Speicherpools zeigen die verlagerten Daten und haben ausreichend freie Kapazität. +- Vorhandene Objekte lassen sich weiterhin auflisten, lesen und herunterladen. -### Verify decommissioning with rc +### Außerbetriebnahme mit rc prüfen -Before removing the pool from the topology, run: +Führen Sie Folgendes aus, bevor Sie den Speicherpool aus der Topologie entfernen: ```bash rc admin decommission status rustfs 0 --by-id ``` -Confirm that the status is `complete` and the failed object and byte counters are zero. After updating `RUSTFS_VOLUMES` and restarting RustFS, run: +Bestätigen Sie, dass der Status `complete` ist und die Zähler für fehlgeschlagene Objekte und Bytes null sind. Führen Sie nach dem Aktualisieren von `RUSTFS_VOLUMES` und dem Neustart von RustFS Folgendes aus: ```bash rc admin pool list rustfs ``` -Verify that only the intended active pools remain. Read objects that previously resided on the retired pool and write a new test object through the S3 endpoint. +Prüfen Sie, dass nur die vorgesehenen aktiven Speicherpools übrig sind. Lesen Sie Objekte, die zuvor auf dem stillgelegten Speicherpool lagen, und schreiben Sie ein neues Testobjekt über den S3-Endpunkt. diff --git a/content/de/operations/scaling/storage-pool-expansion.md b/content/de/operations/scaling/storage-pool-expansion.md index e5cb761e7..dc772bc09 100644 --- a/content/de/operations/scaling/storage-pool-expansion.md +++ b/content/de/operations/scaling/storage-pool-expansion.md @@ -1,104 +1,104 @@ --- -title: "Pool Expansion" -description: "Add a storage pool to a RustFS cluster and verify the expanded topology through the Console or rc." +title: "Speicherpool-Erweiterung" +description: "Fügen Sie einem RustFS-Cluster einen Speicherpool hinzu und prüfen Sie die erweiterte Topologie über die Console oder mit rc." --- -## Overview +## Überblick -### Requirements +### Voraussetzungen -- Install [`rc`](/operations/rc) on the administration host before using the `rc` workflow in this guide. -- Configure credentials with permission to read RustFS cluster and pool status. +- Installieren Sie [`rc`](/de/operations/rc) auf dem Administrationshost, bevor Sie den `rc`-Ablauf in dieser Anleitung verwenden. +- Konfigurieren Sie Zugangsdaten mit der Berechtigung, den RustFS-Cluster- und Speicherpoolstatus zu lesen. -RustFS expands capacity by appending a **server pool** to the cluster topology. Each pool is one space-separated volume expression in `RUSTFS_VOLUMES`. After the expanded topology is applied, new writes can use the added capacity; existing objects remain in their current pools until you run [Rebalancing](./data-rebalancing.md). +RustFS erweitert die Kapazität, indem ein **Speicherpool** an die Cluster-Topologie angehängt wird. Jeder Speicherpool ist ein durch Leerzeichen getrennter Volume-Ausdruck in `RUSTFS_VOLUMES`. Nachdem die erweiterte Topologie angewendet wurde, können neue Schreibvorgänge die zusätzliche Kapazität nutzen. Vorhandene Objekte bleiben in ihren aktuellen Speicherpools, bis Sie ein [Rebalancing](./data-rebalancing.md) ausführen. -This guide uses the following two-pool example: +Diese Anleitung verwendet das folgende Beispiel mit zwei Speicherpools: ```ini title="/etc/default/rustfs" RUSTFS_VOLUMES="http://rustfs-node1:9000/data/rustfs{1...4}/mnmd http://rustfs-node2:9000/data/rustfs{1...4}/mnmd" ``` -Before expanding: +Vor der Erweiterung: -- Back up critical data and run the workflow during a maintenance window. -- Use the same RustFS version, credentials, and complete `RUSTFS_VOLUMES` value on every node. -- Verify name resolution, time synchronization, and port `9000` connectivity between all old and new nodes. -- Prepare the new pool with the intended disk count and storage specification. +- Sichern Sie kritische Daten und führen Sie den Ablauf in einem Wartungsfenster aus. +- Verwenden Sie auf jedem Knoten dieselbe RustFS-Version, dieselben Zugangsdaten und denselben vollständigen Wert von `RUSTFS_VOLUMES`. +- Prüfen Sie Namensauflösung, Zeitsynchronisation und die Erreichbarkeit von Port `9000` zwischen allen bisherigen und neuen Knoten. +- Bereiten Sie den neuen Speicherpool mit der vorgesehenen Laufwerkszahl und Spezifikation vor. -:::warning[Append the pool; do not replace the topology] +:::warning[Hängen Sie den Speicherpool an und ersetzen Sie die Topologie nicht] -Every node must start with the complete ordered pool list. Omitting the existing pool or using a different expression on one node creates an inconsistent topology. +Jeder Knoten muss mit der vollständigen, geordneten Poolliste starten. Wenn Sie den vorhandenen Speicherpool weglassen oder auf einem Knoten einen anderen Ausdruck verwenden, entsteht eine inkonsistente Topologie. ::: -## Operation +## Ablauf -### Expand with Console assistance +### Erweiterung mit Unterstützung der Console -The Console displays storage pools but does not add a pool to the server startup topology. Use this Console-assisted workflow: +Die Console zeigt Speicherpools an, fügt der Starttopologie des Servers aber keinen Speicherpool hinzu. Verwenden Sie diesen Ablauf mit Unterstützung der Console: -1. Record the existing pools and their usage from **Rebalance** or **Pool Decommission**. -2. Install the same RustFS version and service configuration on the new pool node or nodes. -3. Append the new pool expression to `RUSTFS_VOLUMES` on every existing and new node. Keep the existing expressions unchanged and in the same order. -4. Restart RustFS across all nodes so every process starts with the same expanded topology. -5. Wait for all nodes to become ready, then refresh the pool list in the Console. +1. Notieren Sie die vorhandenen Speicherpools und ihre Nutzung unter **Rebalance** (Rebalancing) oder **Pool Decommission** (Speicherpool-Außerbetriebnahme). +2. Installieren Sie auf dem Knoten oder den Knoten des neuen Speicherpools dieselbe RustFS-Version und Dienstkonfiguration. +3. Hängen Sie den Ausdruck des neuen Speicherpools auf jedem vorhandenen und neuen Knoten an `RUSTFS_VOLUMES` an. Lassen Sie die vorhandenen Ausdrücke unverändert und in derselben Reihenfolge. +4. Starten Sie RustFS auf allen Knoten neu, sodass jeder Prozess mit derselben erweiterten Topologie startet. +5. Warten Sie, bis alle Knoten bereit sind, und aktualisieren Sie dann die Poolliste in der Console. -![RustFS Console showing the original and newly added storage pools](./images/pool-expansion-console.png) +![RustFS Console mit dem ursprünglichen und dem neu hinzugefügten Speicherpool](./images/pool-expansion-console.png) -For a Helm deployment, append the new entry to `pools.list` and apply `helm upgrade`. Do not remove or reorder existing entries. +Hängen Sie bei einer Helm-Bereitstellung den neuen Eintrag an `pools.list` an und führen Sie `helm upgrade` aus. Entfernen Sie vorhandene Einträge nicht und ändern Sie ihre Reihenfolge nicht. -### Inspect the expansion with rc +### Erweiterung mit rc einsehen -Configure an alias with credentials that can read cluster and pool status: +Konfigurieren Sie einen Alias mit Zugangsdaten, die Cluster- und Speicherpoolstatus lesen können: ```bash rc alias set rustfs http://:9000 ``` -Record the current topology: +Notieren Sie die aktuelle Topologie: ```bash rc admin pool list rustfs ``` -Prepare the new nodes, append the new pool expression to the complete `RUSTFS_VOLUMES` value on every node, and restart RustFS across the cluster. `rc` does not mutate the server startup topology. +Bereiten Sie die neuen Knoten vor, hängen Sie den Ausdruck des neuen Speicherpools auf jedem Knoten an den vollständigen Wert von `RUSTFS_VOLUMES` an und starten Sie RustFS im gesamten Cluster neu. `rc` ändert die Starttopologie des Servers nicht. -After the cluster returns, list the pools again: +Listen Sie die Speicherpools erneut auf, nachdem der Cluster wieder verfügbar ist: ```bash rc admin pool list rustfs ``` -Use a zero-based pool ID to inspect the new pool in detail: +Verwenden Sie eine nullbasierte Pool-ID, um den neuen Speicherpool im Detail einzusehen: ```bash rc admin pool status rustfs 1 --by-id ``` -:::note[Rebalance aliases] +:::note[Rebalancing-Aliase] -`rc admin expand start`, `status`, and `stop` are aliases for the post-expansion rebalance workflow. They redistribute existing data; they do not append a pool to `RUSTFS_VOLUMES`. +`rc admin expand start`, `status` und `stop` sind Aliase für den Rebalancing-Ablauf nach einer Erweiterung. Sie verteilen vorhandene Daten neu. Sie hängen keinen Speicherpool an `RUSTFS_VOLUMES` an. ::: -## Verification +## Überprüfung -### Verify the expansion in the Console +### Erweiterung in der Console prüfen -Confirm that: +Bestätigen Sie Folgendes: -- The pool list shows the original pool and the new pool. -- Every expected node and disk is online. -- The new pool reports the expected total and available capacity. -- The cluster reports no degraded nodes before you resume normal traffic. +- Die Poolliste zeigt den ursprünglichen und den neuen Speicherpool. +- Jeder erwartete Knoten und jedes erwartete Laufwerk ist online. +- Der neue Speicherpool meldet die erwartete Gesamt- und verfügbare Kapazität. +- Der Cluster meldet keine beeinträchtigten Knoten, bevor Sie den normalen Verkehr wieder aufnehmen. -### Verify the expansion with rc +### Erweiterung mit rc prüfen -Run: +Führen Sie aus: ```bash rc admin pool list rustfs rc admin pool status rustfs 1 --by-id ``` -Verify that the new pool has the expected command-line expression and an active state. Write and read a test object through the normal S3 endpoint before starting a rebalance. +Prüfen Sie, dass der neue Speicherpool den erwarteten Befehlszeilenausdruck und einen aktiven Zustand hat. Schreiben und lesen Sie ein Testobjekt über den normalen S3-Endpunkt, bevor Sie ein Rebalancing starten. diff --git a/content/de/operations/status-check.md b/content/de/operations/status-check.md index 9627a3b5e..3c3551d58 100644 --- a/content/de/operations/status-check.md +++ b/content/de/operations/status-check.md @@ -1,26 +1,26 @@ --- -title: "Status Check" -description: "Check RustFS network access, health endpoints, cluster status, and storage capacity." +title: "Statusprüfung" +description: "Prüfen Sie den Netzwerkzugriff, die Integritätsendpunkte, den Clusterstatus und die Speicherkapazität von RustFS." --- -Use network probes, the **Status** page in the RustFS Console, or the `rc` command line to review RustFS availability and storage consumption. Before using the command-line workflow, [install `rc`](/operations/rc) and configure an alias for the target cluster. +Nutzen Sie Netzwerktests, die Seite **Status** in der RustFS Console (Weboberfläche) oder die Befehlszeile `rc`, um Verfügbarkeit und Speicherverbrauch von RustFS zu prüfen. Bevor Sie den Ablauf über die Befehlszeile verwenden, [installieren Sie `rc`](/de/operations/rc) und konfigurieren Sie einen Alias für den Zielcluster. -## Network ports +## Netzwerkports -RustFS uses two listeners by default. You can change both bind addresses through environment variables or command-line flags. +RustFS verwendet standardmäßig zwei Listener. Beide Bind-Adressen lassen sich über Umgebungsvariablen oder Befehlszeilenoptionen ändern. -| Port | Listener | Configured by | Traffic | +| Port | Listener | Konfiguriert über | Datenverkehr | | --- | --- | --- | --- | -| `9000` | S3 API | `RUSTFS_ADDRESS` / `--address` | S3 object API, admin API, and internal node-to-node RPC under `/rustfs/rpc/` and `/rustfs/peer/` | -| `9001` | Console | `RUSTFS_CONSOLE_ADDRESS` / `--console-address` | Embedded web console under `/rustfs/console/`; disable it with `RUSTFS_CONSOLE_ENABLE=false` | +| `9000` | S3-API | `RUSTFS_ADDRESS` / `--address` | S3-Objekt-API, Admin-API und interne RPC von Knoten zu Knoten unter `/rustfs/rpc/` und `/rustfs/peer/` | +| `9001` | Console | `RUSTFS_CONSOLE_ADDRESS` / `--console-address` | Eingebettete Weboberfläche unter `/rustfs/console/`; deaktivieren Sie sie mit `RUSTFS_CONSOLE_ENABLE=false` | -:::note[Internode connectivity] +:::note[Konnektivität zwischen den Knoten] -Internode RPC shares port 9000. In a multi-node cluster, every node must be able to reach every other node on the S3 port; there is no separate cluster port. +Die RPC zwischen den Knoten nutzt Port 9000 mit. In einem Cluster mit mehreren Knoten muss jeder Knoten jeden anderen Knoten auf dem S3-Port erreichen können. Einen eigenen Cluster-Port gibt es nicht. ::: -Open the default ports with `firewalld` when clients need to reach both listeners: +Öffnen Sie die Standardports mit `firewalld`, wenn Clients beide Listener erreichen müssen: ```bash title="firewall-cmd" firewall-cmd --permanent --add-port=9000/tcp @@ -28,25 +28,25 @@ firewall-cmd --permanent --add-port=9001/tcp firewall-cmd --reload ``` -:::warning[Restrict console access] +:::warning[Zugriff auf die Console einschränken] -Expose port 9001 only to trusted networks. If you do not need the console, set `RUSTFS_CONSOLE_ENABLE=false` and leave the port closed. +Geben Sie Port 9001 nur für vertrauenswürdige Netze frei. Wenn Sie die Console nicht benötigen, setzen Sie `RUSTFS_CONSOLE_ENABLE=false` und lassen Sie den Port geschlossen. ::: -## Health endpoints +## Endpunkte für Integritätsprüfungen -The S3 listener on port **9000** serves unauthenticated probe endpoints. Disable them with `RUSTFS_HEALTH_ENDPOINT_ENABLE=false`. The console on port **9001** has its own health path. +Der S3-Listener auf Port **9000** stellt unauthentifizierte Prüf-Endpunkte bereit. Deaktivieren Sie sie mit `RUSTFS_HEALTH_ENDPOINT_ENABLE=false`. Die Console auf Port **9001** hat einen eigenen Integritätspfad. -| Endpoint | Port | Meaning | +| Endpunkt | Port | Bedeutung | | --- | --- | --- | -| `GET /health`, `HEAD /health`, `GET /health/live`, `GET /minio/health/live` | 9000 | Liveness — returns `200` as long as the process is up | -| `GET /health/ready` | 9000 | Readiness — `200` only when storage, IAM, and peer health are ready; `503` otherwise | -| `GET /minio/health/ready` | 9000 | MinIO-compatible alias of the readiness probe | -| `GET /minio/health/cluster`, `GET /minio/health/cluster/read` | 9000 | Cluster write/read health (additionally require lock quorum) | -| `GET /rustfs/console/health` | 9001 | Console process health | +| `GET /health`, `HEAD /health`, `GET /health/live`, `GET /minio/health/live` | 9000 | Liveness: liefert `200`, solange der Prozess läuft | +| `GET /health/ready` | 9000 | Bereitschaft: `200` nur, wenn Speicher, IAM und der Zustand der Peers bereit sind; andernfalls `503` | +| `GET /minio/health/ready` | 9000 | MinIO-kompatibler Alias der Bereitschaftsprüfung | +| `GET /minio/health/cluster`, `GET /minio/health/cluster/read` | 9000 | Schreib- und Leseintegrität des Clusters (erfordert zusätzlich Lock-Quorum) | +| `GET /rustfs/console/health` | 9001 | Integrität des Console-Prozesses | -A ready node answers `200` with `"ready": true`. A degraded node answers `503` with per-dependency detail: +Ein bereiter Knoten antwortet mit `200` und `"ready": true`. Ein beeinträchtigter Knoten antwortet mit `503` und Details je Abhängigkeit: ```bash title="Probe examples" curl -fsS http://localhost:9000/health @@ -54,60 +54,60 @@ curl -s http://:9000/health/ready | jq curl -fsS http://localhost:9001/rustfs/console/health ``` -The `details` object reports `storage` / `iam` / `lock` (and `kms` when configured), and `degradedReasons` lists machine-readable causes such as `storage_quorum_unavailable`, `iam_not_ready`, or `lock_quorum_unavailable`. +Das Objekt `details` meldet `storage`, `iam` und `lock` (sowie `kms`, wenn konfiguriert). `degradedReasons` listet maschinenlesbare Ursachen wie `storage_quorum_unavailable`, `iam_not_ready` oder `lock_quorum_unavailable`. -## Cluster status +## Clusterstatus -### Check cluster status in the Console +### Clusterstatus in der Console prüfen -1. Sign in to the RustFS Console. -2. Open **Status**. -3. Confirm that the cluster is online and review the server, network, and drive status. -4. Investigate any offline server, unavailable drive, or failed network connection before maintenance or capacity changes. +1. Melden Sie sich an der RustFS Console an. +2. Öffnen Sie **Status**. +3. Bestätigen Sie, dass der Cluster online ist, und prüfen Sie den Status von Servern, Netzwerk und Laufwerken. +4. Klären Sie jeden offline geschalteten Server, jedes nicht verfügbare Laufwerk und jede fehlgeschlagene Netzwerkverbindung, bevor Sie Wartung oder Kapazitätsänderungen vornehmen. -### Check cluster status with rc +### Clusterstatus mit rc prüfen -Run the cluster information command with your configured alias: +Führen Sie den Befehl für Clusterinformationen mit Ihrem konfigurierten Alias aus: ```bash rc admin info cluster rustfs ``` -The overview reports the cluster state, RustFS version, server and disk counts, backend type, and erasure-coding parity. The node list shows uptime, network connectivity, drive availability, and pool membership. The disk list shows each drive's state and pool, set, and disk location. +Die Übersicht meldet den Clusterzustand, die RustFS-Version, die Zahl der Server und Laufwerke, den Backend-Typ und die Parität des Erasure Coding. Die Knotenliste zeigt Laufzeit, Netzwerkkonnektivität, Verfügbarkeit der Laufwerke und die Poolzugehörigkeit. Die Laufwerksliste zeigt Zustand sowie Pool, Set und Laufwerksposition jedes Laufwerks. -For machine-readable output, request JSON: +Fordern Sie für maschinenlesbare Ausgabe JSON an: ```bash rc admin info cluster rustfs --json ``` -## Storage capacity +## Speicherkapazität -### Check storage capacity in the Console +### Speicherkapazität in der Console prüfen -1. Sign in to the RustFS Console and open **Status**. -2. Review the cluster's used and total storage capacity. -3. Review the capacity and available space for each disk. -4. Compare usage over time and plan expansion before available capacity becomes insufficient for normal writes and maintenance. +1. Melden Sie sich an der RustFS Console an und öffnen Sie **Status**. +2. Prüfen Sie die genutzte und die gesamte Speicherkapazität des Clusters. +3. Prüfen Sie Kapazität und verfügbaren Speicher jedes Laufwerks. +4. Vergleichen Sie die Nutzung über die Zeit und planen Sie eine Erweiterung, bevor die verfügbare Kapazität für normale Schreibvorgänge und Wartung nicht mehr ausreicht. -### Check storage capacity with rc +### Speicherkapazität mit rc prüfen -Use the same cluster information command: +Verwenden Sie denselben Befehl für Clusterinformationen: ```bash rc admin info cluster rustfs ``` -The **Storage** summary reports used capacity, total capacity, and the used percentage for the cluster. Each entry under **Disks** reports used, total, and available capacity for that drive. +Die Zusammenfassung **Storage** (Speicher) meldet genutzte Kapazität, Gesamtkapazität und den genutzten Prozentsatz des Clusters. Jeder Eintrag unter **Disks** (Laufwerke) meldet genutzte, gesamte und verfügbare Kapazität dieses Laufwerks. -Use JSON output when collecting the values in a script or monitoring integration: +Verwenden Sie die JSON-Ausgabe, wenn Sie die Werte in einem Skript oder einer Monitoring-Integration erfassen: ```bash rc admin info cluster rustfs --json ``` -Administrative information commands require credentials with the corresponding RustFS Admin API permissions. +Administrative Informationsbefehle erfordern Zugangsdaten mit den entsprechenden Berechtigungen der RustFS Admin API. -## Next steps +## Nächste Schritte -For continuous telemetry and alerting, continue with [Observability](./observability.md). To add storage, review [Pool Expansion](./scaling/storage-pool-expansion.md). +Für fortlaufende Telemetrie und Alarmierung fahren Sie mit [Observability](./observability.md) fort. Um Speicher hinzuzufügen, lesen Sie [Speicherpool-Erweiterung](./scaling/storage-pool-expansion.md). diff --git a/content/de/operations/upgrade/binary/index.md b/content/de/operations/upgrade/binary/index.md index 594d2abe0..3fade084e 100644 --- a/content/de/operations/upgrade/binary/index.md +++ b/content/de/operations/upgrade/binary/index.md @@ -1,28 +1,28 @@ --- -title: "Binary Upgrade" -description: "Upgrade RustFS binary deployments one node at a time while preserving cluster availability." +title: "Binär-Upgrade" +description: "Aktualisieren Sie RustFS-Binärbereitstellungen knotenweise und erhalten Sie dabei die Verfügbarkeit des Clusters." --- -Use a rolling upgrade to replace the RustFS executable on each node without taking the entire cluster offline. Before you begin, read the target release notes and confirm every node is healthy. +Ersetzen Sie die ausführbare RustFS-Datei mit einem rollierenden Upgrade auf jedem Knoten, ohne den gesamten Cluster offline zu nehmen. Lesen Sie vor Beginn die Versionshinweise der Zielversion und bestätigen Sie, dass jeder Knoten betriebsbereit ist. -## Before you upgrade +## Vor dem Upgrade -Check readiness on every node: +Prüfen Sie die Bereitschaft auf jedem Knoten: ```bash curl -fsS http://:9000/health/ready ``` -Back up the service configuration and retain the currently running executable for rollback: +Sichern Sie die Dienstkonfiguration und behalten Sie die aktuell laufende ausführbare Datei für das Zurücksetzen: ```bash sudo cp /etc/default/rustfs /etc/default/rustfs.bak sudo cp /usr/local/bin/rustfs /usr/local/bin/rustfs.previous ``` -## Upgrade each node +## Jeden Knoten aktualisieren -Upgrade one node at a time. Do not continue until the restarted node reports ready. +Aktualisieren Sie jeweils einen Knoten. Fahren Sie nicht fort, bevor der neu gestartete Knoten Bereitschaft meldet. ```bash sudo systemctl stop rustfs @@ -32,11 +32,11 @@ sudo systemctl start rustfs curl -fsS http://:9000/health/ready ``` -Repeat the procedure for each remaining node. +Wiederholen Sie das Vorgehen für jeden verbleibenden Knoten. -## Roll back +## Zurücksetzen -If the new version fails validation, restore the previous executable on one node at a time and wait for readiness before continuing: +Wenn die neue Version die Prüfung nicht besteht, stellen Sie die vorherige ausführbare Datei knotenweise wieder her und warten Sie auf Bereitschaft, bevor Sie fortfahren: ```bash sudo systemctl stop rustfs @@ -45,6 +45,6 @@ sudo systemctl start rustfs curl -fsS http://:9000/health/ready ``` -## Next steps +## Nächste Schritte -Review [Status Check](/operations/status-check) for additional post-upgrade validation. \ No newline at end of file +Weitere Prüfungen nach dem Upgrade finden Sie unter [Statusprüfung](/de/operations/status-check). diff --git a/content/de/operations/upgrade/container/index.md b/content/de/operations/upgrade/container/index.md index e9e388f14..3666c562d 100644 --- a/content/de/operations/upgrade/container/index.md +++ b/content/de/operations/upgrade/container/index.md @@ -1,45 +1,45 @@ --- -title: "Container Upgrade" -description: "Upgrade RustFS containers started with Docker, Podman, or Docker Compose while preserving persistent data." +title: "Container-Upgrade" +description: "Aktualisieren Sie mit Docker, Podman oder Docker Compose gestartete RustFS-Container und behalten Sie persistente Daten bei." --- -Upgrade a container deployment by recreating the RustFS container from a newer image. Choose the workflow that matches the original installation method: a container started directly with Docker or Podman, or a service managed by Docker Compose. +Aktualisieren Sie eine Container-Bereitstellung, indem Sie den RustFS-Container aus einem neueren Image neu erzeugen. Wählen Sie den Ablauf, der zur ursprünglichen Installationsmethode passt: ein direkt mit Docker oder Podman gestarteter Container oder ein von Docker Compose verwalteter Dienst. -## Before you upgrade +## Vor dem Upgrade -Read the target release notes and use an explicit image tag for the upgrade. Record the current image and retain the original `docker run`, `podman run`, or Compose configuration because recreating a container does not copy its runtime options automatically. +Lesen Sie die Versionshinweise der Zielversion und verwenden Sie für das Upgrade ein explizites Image-Tag. Notieren Sie das aktuelle Image und bewahren Sie die ursprüngliche Konfiguration von `docker run`, `podman run` oder Compose auf, weil das Neuerzeugen eines Containers dessen Laufzeitoptionen nicht automatisch übernimmt. -Confirm that RustFS is healthy before replacing it: +Bestätigen Sie, dass RustFS betriebsbereit ist, bevor Sie es ersetzen: ```bash curl -fsS http://localhost:9000/health/ready ``` -:::warning[Preserve persistent storage] +:::warning[Persistenten Speicher bewahren] -Do not remove the named volume or host directory mounted at `/data`. Commands such as `docker compose down -v`, `docker volume rm`, and `podman volume rm` delete persistent storage and are not part of an upgrade. +Entfernen Sie weder das benannte Volume noch das Hostverzeichnis, das unter `/data` eingehängt ist. Befehle wie `docker compose down -v`, `docker volume rm` und `podman volume rm` löschen persistenten Speicher und gehören nicht zu einem Upgrade. ::: -## Upgrade a Docker container +## Einen Docker-Container aktualisieren -The following workflow matches the container name and named volume used in the [Docker installation guide](/installation/container/docker). If your deployment uses different ports, environment variables, mounts, or startup arguments, keep those settings unchanged in the replacement command. +Der folgende Ablauf entspricht dem Containernamen und dem benannten Volume aus der [Docker-Installationsanleitung](/de/installation/container/docker). Wenn Ihre Bereitstellung andere Ports, Umgebungsvariablen, Einhängungen oder Startargumente verwendet, lassen Sie diese Einstellungen im Ersatzbefehl unverändert. -Record the current image, then pull the target version: +Notieren Sie das aktuelle Image und ziehen Sie dann die Zielversion: ```bash docker inspect --format '{{.Config.Image}}' rustfs docker pull rustfs/rustfs: ``` -Stop and remove only the container. The `rustfs-data` volume remains intact: +Stoppen und entfernen Sie nur den Container. Das Volume `rustfs-data` bleibt erhalten: ```bash docker stop rustfs docker rm rustfs ``` -Recreate the container with the original configuration and the target image: +Erzeugen Sie den Container mit der ursprünglichen Konfiguration und dem Ziel-Image neu: ```bash docker run -d \ @@ -59,7 +59,7 @@ docker run -d \ /data ``` -Wait for the replacement container to become healthy: +Warten Sie, bis der Ersatzcontainer betriebsbereit ist: ```bash docker ps --filter name=rustfs @@ -67,9 +67,9 @@ docker logs rustfs curl -fsS http://localhost:9000/health/ready ``` -## Upgrade a Podman container +## Einen Podman-Container aktualisieren -The Podman workflow is the same replacement operation, using the image name from the [Podman installation guide](/installation/container/podman). +Der Podman-Ablauf ist derselbe Ersatzvorgang und verwendet den Image-Namen aus der [Podman-Installationsanleitung](/de/installation/container/podman). ```bash podman inspect --format '{{.Config.Image}}' rustfs @@ -78,7 +78,7 @@ podman stop rustfs podman rm rustfs ``` -Recreate the container with the original configuration and persistent volume: +Erzeugen Sie den Container mit der ursprünglichen Konfiguration und dem persistenten Volume neu: ```bash podman run -d \ @@ -97,7 +97,7 @@ podman run -d \ /data ``` -Verify the replacement before continuing: +Prüfen Sie den Ersatz, bevor Sie fortfahren: ```bash podman ps --filter name=rustfs @@ -105,16 +105,16 @@ podman logs rustfs curl -fsS http://localhost:9000/health/ready ``` -## Upgrade with Docker Compose +## Mit Docker Compose aktualisieren -Run Compose commands from the directory containing the deployment's `docker-compose.yml`. Before the upgrade, save the fully resolved configuration and confirm the current image: +Führen Sie Compose-Befehle aus dem Verzeichnis aus, das die `docker-compose.yml` der Bereitstellung enthält. Speichern Sie vor dem Upgrade die vollständig aufgelöste Konfiguration und bestätigen Sie das aktuelle Image: ```bash docker compose config > docker-compose.resolved.yaml docker compose images rustfs ``` -Change the `rustfs` service to an explicit target image tag while leaving its volumes, environment, ports, and command unchanged: +Setzen Sie den Dienst `rustfs` auf ein explizites Ziel-Image-Tag und lassen Sie Volumes, Umgebung, Ports und Befehl unverändert: ```yaml title="docker-compose.yml" services: @@ -122,7 +122,7 @@ services: image: rustfs/rustfs: ``` -Validate the file, pull the target image, and recreate only the RustFS service. `--no-deps` leaves optional observability services running: +Prüfen Sie die Datei, ziehen Sie das Ziel-Image und erzeugen Sie nur den RustFS-Dienst neu. `--no-deps` lässt optionale Observability-Dienste weiterlaufen: ```bash docker compose config --quiet @@ -130,7 +130,7 @@ docker compose pull rustfs docker compose up -d --no-deps rustfs ``` -Check the service and the RustFS readiness endpoint: +Prüfen Sie den Dienst und den Bereitschafts-Endpunkt von RustFS: ```bash docker compose ps rustfs @@ -138,19 +138,19 @@ docker compose logs --tail=100 rustfs curl -fsS http://localhost:9000/health/ready ``` -If you started RustFS together with the `observability` profile, the RustFS service still upgrades with the same commands. Upgrade observability images separately according to each component's release notes. +Wenn Sie RustFS zusammen mit dem Profil `observability` gestartet haben, wird der RustFS-Dienst mit denselben Befehlen aktualisiert. Aktualisieren Sie Observability-Images getrennt nach den Versionshinweisen der jeweiligen Komponente. -## Upgrade a multi-node deployment +## Eine Bereitstellung mit mehreren Knoten aktualisieren -Replace one RustFS node at a time. Wait for the upgraded node's readiness endpoint to succeed and confirm cluster status before proceeding to the next node. Do not recreate all nodes simultaneously. +Ersetzen Sie jeweils einen RustFS-Knoten. Warten Sie, bis der Bereitschafts-Endpunkt des aktualisierten Knotens erfolgreich antwortet, und bestätigen Sie den Clusterstatus, bevor Sie zum nächsten Knoten wechseln. Erzeugen Sie nicht alle Knoten gleichzeitig neu. -Use the same Docker, Podman, or Compose workflow on each node, preserving that node's existing mounts and configuration. +Verwenden Sie auf jedem Knoten denselben Ablauf für Docker, Podman oder Compose und behalten Sie die vorhandenen Einhängungen und die Konfiguration dieses Knotens bei. -## Roll back +## Zurücksetzen -For Docker or Podman, stop and remove the failed replacement container, then repeat the corresponding `run` command with the previously recorded image tag. Keep the same persistent volume and runtime configuration. +Stoppen und entfernen Sie bei Docker oder Podman den fehlgeschlagenen Ersatzcontainer und wiederholen Sie den zugehörigen `run`-Befehl mit dem zuvor notierten Image-Tag. Behalten Sie dasselbe persistente Volume und dieselbe Laufzeitkonfiguration bei. -For Docker Compose, restore the previous `image` value in `docker-compose.yml`, then recreate the RustFS service: +Setzen Sie bei Docker Compose den vorherigen Wert von `image` in `docker-compose.yml` wieder ein und erzeugen Sie dann den RustFS-Dienst neu: ```bash docker compose pull rustfs @@ -158,8 +158,8 @@ docker compose up -d --no-deps rustfs curl -fsS http://localhost:9000/health/ready ``` -In a multi-node deployment, roll back one node at a time and wait for readiness before continuing. +Setzen Sie in einer Bereitstellung mit mehreren Knoten jeweils einen Knoten zurück und warten Sie auf Bereitschaft, bevor Sie fortfahren. -## Next steps +## Nächste Schritte -Review [Status Check](/operations/status-check) for additional post-upgrade validation. \ No newline at end of file +Weitere Prüfungen nach dem Upgrade finden Sie unter [Statusprüfung](/de/operations/status-check). diff --git a/content/de/operations/upgrade/index.md b/content/de/operations/upgrade/index.md index b9521a4a7..d025600aa 100644 --- a/content/de/operations/upgrade/index.md +++ b/content/de/operations/upgrade/index.md @@ -1,14 +1,14 @@ --- title: "Upgrade" -description: "Plan and perform RustFS upgrades while preserving cluster availability." +description: "Planen und führen Sie RustFS-Upgrades aus und erhalten Sie dabei die Verfügbarkeit des Clusters." --- -Choose the upgrade workflow that matches how you deploy RustFS. For multi-node clusters, replace one node or pod at a time and wait for it to report ready before continuing. +Wählen Sie den Upgrade-Ablauf, der zu Ihrer RustFS-Bereitstellung passt. Ersetzen Sie in Clustern mit mehreren Knoten jeweils einen Knoten oder ein Pod und warten Sie, bis er Bereitschaft meldet, bevor Sie fortfahren. -## Deployment methods +## Bereitstellungsmethoden -- [Binary Upgrade](./binary/index.md) covers systemd-managed executable replacement and rollback. -- [Container Upgrade](./container/index.md) covers image replacement with persistent data volumes. -- [Kubernetes Upgrade](./kubernetes/index.md) covers Helm- and Operator-managed workloads. +- [Binär-Upgrade](./binary/index.md) behandelt den Austausch der ausführbaren Datei unter systemd und das Zurücksetzen. +- [Container-Upgrade](./container/index.md) behandelt den Austausch des Images bei persistenten Daten-Volumes. +- [Kubernetes-Upgrade](./kubernetes/index.md) behandelt Workloads unter Helm und dem Operator. -Before any upgrade, read the target release notes and confirm the cluster is healthy. \ No newline at end of file +Lesen Sie vor jedem Upgrade die Versionshinweise der Zielversion und bestätigen Sie, dass der Cluster betriebsbereit ist. diff --git a/content/de/operations/upgrade/kubernetes/index.md b/content/de/operations/upgrade/kubernetes/index.md index 9914e1465..c400a16c2 100644 --- a/content/de/operations/upgrade/kubernetes/index.md +++ b/content/de/operations/upgrade/kubernetes/index.md @@ -1,26 +1,26 @@ --- -title: "Kubernetes Upgrade" -description: "Upgrade RustFS deployments managed by the Helm chart or RustFS Operator and verify each rollout." +title: "Kubernetes-Upgrade" +description: "Aktualisieren Sie RustFS-Bereitstellungen unter dem Helm-Chart oder dem RustFS Operator und prüfen Sie jedes Rollout." --- -Upgrade a Kubernetes deployment through the tool that owns its resources. Use Helm for a direct RustFS Helm chart installation. For an Operator installation, upgrade the Operator release and each Tenant through their respective declarative configurations. +Aktualisieren Sie eine Kubernetes-Bereitstellung über das Werkzeug, dem ihre Ressourcen gehören. Verwenden Sie Helm für eine direkte Installation mit dem RustFS-Helm-Chart. Bei einer Operator-Installation aktualisieren Sie das Operator-Release und jeden Tenant über die jeweiligen deklarativen Konfigurationen. -## Before you upgrade +## Vor dem Upgrade -Read the RustFS, chart, and Operator release notes that apply to your deployment. Confirm that the cluster has enough capacity to replace pods and that all current workloads are ready: +Lesen Sie die Versionshinweise von RustFS, Chart und Operator, die für Ihre Bereitstellung gelten. Bestätigen Sie, dass der Cluster genug Kapazität hat, um Pods zu ersetzen, und dass alle aktuellen Workloads bereit sind: ```bash kubectl get nodes kubectl -n get pods,pvc ``` -Do not delete PersistentVolumeClaims (PVCs) during an upgrade or rollback. Keep the existing deployment values and manifests under version control, including any image tags, storage topology, scheduling rules, and Secret references. +Löschen Sie während eines Upgrades oder Rollbacks keine PersistentVolumeClaims (PVCs). Behalten Sie die vorhandenen Werte und Manifeste der Bereitstellung unter Versionsverwaltung, einschließlich Image-Tags, Speichertopologie, Scheduling-Regeln und Secret-Verweisen. -## Upgrade a Helm chart deployment +## Eine Helm-Chart-Bereitstellung aktualisieren -This workflow applies to RustFS installed directly with the [RustFS Helm chart](/installation/cloud-native/helm-chart/installation). It does not apply to a Tenant created by RustFS Operator. +Dieser Ablauf gilt für RustFS, das direkt mit dem [RustFS-Helm-Chart](/de/installation/cloud-native/helm-chart/installation) installiert wurde. Er gilt nicht für einen Tenant, den der RustFS Operator angelegt hat. -Record the current release revision, chart version, application version, and effective user-supplied values: +Notieren Sie die aktuelle Release-Revision, die Chart-Version, die Anwendungsversion und die wirksam gesetzten, von Ihnen gelieferten Werte: ```bash helm status rustfs --namespace rustfs @@ -28,20 +28,20 @@ helm history rustfs --namespace rustfs helm get values rustfs --namespace rustfs -o yaml > rustfs-values.previous.yaml ``` -Prepare the target chart in the same way as the installation. If you use the chart repository, update its index and set the chart reference: +Bereiten Sie das Ziel-Chart auf dieselbe Weise vor wie bei der Installation. Wenn Sie das Chart-Repository verwenden, aktualisieren Sie dessen Index und setzen Sie die Chart-Referenz: ```bash helm repo update rustfs export RUSTFS_CHART=rustfs/rustfs ``` -If you use a source checkout, check out the target RustFS release and point `RUSTFS_CHART` at its chart directory: +Wenn Sie einen Quellcode-Checkout verwenden, checken Sie das RustFS-Zielrelease aus und lassen Sie `RUSTFS_CHART` auf dessen Chart-Verzeichnis zeigen: ```bash export RUSTFS_CHART=./helm/rustfs ``` -Update your maintained values file for any release-specific changes. Set `image.rustfs.tag` to the explicit RustFS version you intend to run, then apply the upgrade: +Aktualisieren Sie Ihre gepflegte Values-Datei um release-spezifische Änderungen. Setzen Sie `image.rustfs.tag` auf die konkrete RustFS-Version, die Sie betreiben wollen, und führen Sie dann das Upgrade aus: ```bash helm upgrade rustfs "$RUSTFS_CHART" \ @@ -52,34 +52,34 @@ helm upgrade rustfs "$RUSTFS_CHART" \ --timeout 10m ``` -Helm performs a rolling update. Monitor the release and pods until the rollout completes: +Helm führt eine rollierende Aktualisierung aus. Beobachten Sie das Release und die Pods, bis das Rollout abgeschlossen ist: ```bash helm status rustfs --namespace rustfs kubectl -n rustfs get pods,pvc,services ``` -Distributed mode creates a StatefulSet: +Der verteilte Modus erzeugt ein StatefulSet: ```bash kubectl -n rustfs rollout status statefulset/rustfs --timeout=10m ``` -Standalone mode creates a Deployment: +Der eigenständige Modus erzeugt ein Deployment: ```bash kubectl -n rustfs rollout status deployment/rustfs --timeout=10m ``` -Verify the S3 API after the rollout. If it is not exposed outside the cluster, start the port forward documented in the installation guide first: +Prüfen Sie nach dem Rollout die S3-API. Wenn sie außerhalb des Clusters nicht erreichbar ist, starten Sie zuerst die Portweiterleitung aus der Installationsanleitung: ```bash curl -fsS http://localhost:9000/health/ready ``` -### Roll back a Helm release +### Ein Helm-Release zurücksetzen -List the release history, identify the last working revision, and let Helm restore its chart, values, and image configuration: +Listen Sie die Release-Historie auf, ermitteln Sie die letzte funktionierende Revision und lassen Sie Helm Chart, Werte und Image-Konfiguration wiederherstellen: ```bash helm history rustfs --namespace rustfs @@ -89,20 +89,20 @@ helm rollback rustfs \ --timeout 10m ``` -Check the workload and readiness endpoint again after rollback. Do not uninstall the release or delete its PVCs. +Prüfen Sie nach dem Rollback erneut den Workload und den Bereitschafts-Endpunkt. Deinstallieren Sie das Release nicht und löschen Sie seine PVCs nicht. -## Upgrade an Operator deployment +## Eine Operator-Bereitstellung aktualisieren -An Operator deployment has two independent upgrade surfaces: +Eine Operator-Bereitstellung hat zwei unabhängige Upgrade-Ebenen: -- The RustFS Operator and Operator Console run from the `rustfs-operator` Helm release. -- Each Tenant runs the RustFS image declared in that Tenant's `spec.image` field. +- Der RustFS Operator und die Operator Console laufen aus dem Helm-Release `rustfs-operator`. +- Jeder Tenant führt das RustFS-Image aus, das im Feld `spec.image` dieses Tenants steht. -Upgrade and validate the Operator control plane before changing Tenant images. Do not combine an Operator upgrade with multiple Tenant upgrades in one maintenance step. +Aktualisieren und prüfen Sie die Steuerungsebene des Operators, bevor Sie Tenant-Images ändern. Kombinieren Sie ein Operator-Upgrade nicht mit mehreren Tenant-Upgrades in einem Wartungsschritt. -### Upgrade the Operator release +### Das Operator-Release aktualisieren -Record the current release and save its values: +Notieren Sie das aktuelle Release und speichern Sie seine Werte: ```bash helm status rustfs-operator --namespace rustfs-system @@ -111,7 +111,7 @@ helm get values rustfs-operator --namespace rustfs-system -o yaml \ > rustfs-operator-values.previous.yaml ``` -Update the Operator source checkout to the target release and review changes to its chart values and CustomResourceDefinitions (CRDs). Helm does not upgrade CRDs stored in a chart's `crds/` directory, so apply both target CRDs before upgrading the controller: +Aktualisieren Sie den Quellcode-Checkout des Operators auf das Zielrelease und prüfen Sie Änderungen an den Chart-Werten und den CustomResourceDefinitions (CRDs). Helm aktualisiert CRDs im Verzeichnis `crds/` eines Charts nicht. Wenden Sie deshalb beide Ziel-CRDs an, bevor Sie den Controller aktualisieren: ```bash kubectl apply --server-side --force-conflicts \ @@ -122,7 +122,7 @@ kubectl apply --server-side --force-conflicts \ -f deploy/rustfs-operator/crds/policybinding-crd.yaml ``` -The CRDs are cluster-scoped and shared by every Tenant namespace. Applying them first allows the Kubernetes API server to accept fields introduced by the new controller. After both commands succeed, upgrade the Operator with your maintained values file: +Die CRDs gelten clusterweit und werden von jedem Tenant-Namespace gemeinsam genutzt. Wenn Sie sie zuerst anwenden, kann der Kubernetes-API-Server Felder annehmen, die der neue Controller einführt. Nachdem beide Befehle erfolgreich waren, aktualisieren Sie den Operator mit Ihrer gepflegten Values-Datei: ```bash helm upgrade rustfs-operator deploy/rustfs-operator/ \ @@ -134,7 +134,7 @@ helm upgrade rustfs-operator deploy/rustfs-operator/ \ --timeout 10m ``` -Verify the CRDs and all control-plane components before upgrading a Tenant: +Prüfen Sie die CRDs und alle Komponenten der Steuerungsebene, bevor Sie einen Tenant aktualisieren: ```bash kubectl get crd tenants.rustfs.com @@ -143,7 +143,7 @@ kubectl -n rustfs-system rollout status deployment/rustfs-operator-console --tim kubectl get tenants --all-namespaces ``` -CRD changes are not part of Helm release history and `helm rollback` does not restore them. Review the target release's compatibility and migration notes before considering a controller rollback. If that release explicitly supports downgrading, restore the previous Helm revision without applying older CRD files: +CRD-Änderungen gehören nicht zur Helm-Release-Historie, und `helm rollback` stellt sie nicht wieder her. Lesen Sie die Kompatibilitäts- und Migrationshinweise des Zielreleases, bevor Sie ein Rollback des Controllers erwägen. Wenn dieses Release ein Downgrade ausdrücklich unterstützt, stellen Sie die vorherige Helm-Revision wieder her, ohne ältere CRD-Dateien anzuwenden: ```bash helm history rustfs-operator --namespace rustfs-system @@ -153,13 +153,13 @@ helm rollback rustfs-operator \ --timeout 10m ``` -Do not downgrade across a documented one-way workload or security migration. Roll forward to a fixed Operator release instead. +Führen Sie kein Downgrade über eine dokumentierte Einwegmigration von Workload oder Sicherheit hinweg aus. Rollen Sie stattdessen vorwärts auf ein korrigiertes Operator-Release. -### Upgrade a Tenant +### Einen Tenant aktualisieren -The Operator owns each Tenant's StatefulSets. Do not change their container images directly because reconciliation restores the image declared by the Tenant. +Der Operator besitzt die StatefulSets jedes Tenants. Ändern Sie deren Container-Images nicht direkt, weil die Reconciliation das vom Tenant deklarierte Image wiederherstellt. -Record the current Tenant image and confirm its `Ready` condition: +Notieren Sie das aktuelle Tenant-Image und bestätigen Sie die Bedingung `Ready`: ```bash kubectl -n storage-a get tenant tenant-a \ @@ -168,7 +168,7 @@ kubectl -n storage-a get tenant tenant-a kubectl -n storage-a get pods,pvc -l rustfs.tenant=tenant-a ``` -In the complete `tenant.yaml` used to install the Tenant, change only `spec.image` to `rustfs/rustfs:`. Leave its pools, PVC templates, credentials, and other settings unchanged. Apply the complete manifest and wait for the Operator to reconcile the new generation: +Ändern Sie in der vollständigen `tenant.yaml`, mit der Sie den Tenant installiert haben, nur `spec.image` auf `rustfs/rustfs:`. Lassen Sie Speicherpools, PVC-Vorlagen, Zugangsdaten und die übrigen Einstellungen unverändert. Wenden Sie das vollständige Manifest an und warten Sie, bis der Operator die neue Generation abgeglichen hat: ```bash kubectl apply -f tenant.yaml @@ -178,11 +178,11 @@ kubectl -n storage-a wait tenant/tenant-a \ kubectl -n storage-a get pods -l rustfs.tenant=tenant-a ``` -Upgrade one Tenant at a time. Confirm its S3 API and [cluster status](/operations/status-check) before updating another Tenant. +Aktualisieren Sie jeweils einen Tenant. Bestätigen Sie seine S3-API und den [Clusterstatus](/de/operations/status-check), bevor Sie einen weiteren Tenant aktualisieren. -### Roll back a Tenant +### Einen Tenant zurücksetzen -Restore the previously recorded image in `spec.image`, apply the complete Tenant manifest, and wait for `Ready` again: +Setzen Sie das zuvor notierte Image in `spec.image` wieder ein, wenden Sie das vollständige Tenant-Manifest an und warten Sie erneut auf `Ready`: ```bash kubectl apply -f tenant.yaml @@ -191,8 +191,8 @@ kubectl -n storage-a wait tenant/tenant-a \ --timeout=10m ``` -The Operator reuses the Tenant's existing PVCs. Do not delete the Tenant, its StatefulSets, or its PVCs during rollback. +Der Operator verwendet die vorhandenen PVCs des Tenants weiter. Löschen Sie während des Rollbacks weder den Tenant noch seine StatefulSets oder PVCs. -## Next steps +## Nächste Schritte -Review [Status Check](/operations/status-check) and [Observability](/operations/observability) to validate the deployment after the rollout. \ No newline at end of file +Prüfen Sie nach dem Rollout die Bereitstellung über [Statusprüfung](/de/operations/status-check) und [Observability](/de/operations/observability). diff --git a/content/de/reference/cli.md b/content/de/reference/cli.md index 47fc0a905..53e72ce66 100644 --- a/content/de/reference/cli.md +++ b/content/de/reference/cli.md @@ -1,20 +1,20 @@ --- -title: "CLI Reference" -description: "Reference for the rustfs subcommands, server flags, environment variable equivalents, and volume path syntax." +title: "CLI-Referenz" +description: "Referenz der Unterbefehle von rustfs, der Server-Flags, der äquivalenten Umgebungsvariablen und der Syntax für Volume-Pfade." --- -The `rustfs` binary ships six subcommands. Running `rustfs` with no subcommand starts the server. +Das Binary `rustfs` enthält sechs Unterbefehle. Wenn Sie `rustfs` ohne Unterbefehl ausführen, startet der Server. -## Subcommands +## Unterbefehle -| Command | Description | +| Befehl | Beschreibung | | --- | --- | -| `rustfs server [OPTIONS] ...` | Start the object storage server (default when no subcommand is given). | -| `rustfs info [--all] [--json] [system\|runtime\|build\|config\|deps]` | Display system, runtime, build, configuration, or dependency information. | -| `rustfs tls inspect --path ` | Inspect a TLS certificate directory layout and parsing status. | -| `rustfs diagnose [OPTIONS] ...` | Analyze log files and report probable failure causes. | -| `rustfs inspect ` | Inspect persisted bucket metadata without a running server. | -| `rustfs connect ` | Configure outbound RustFS Connect integration. | +| `rustfs server [OPTIONS] ...` | Startet den Objektspeicher-Server (Standard, wenn kein Unterbefehl angegeben ist). | +| `rustfs info [--all] [--json] [system\|runtime\|build\|config\|deps]` | Zeigt Informationen zu System, Laufzeit, Build, Konfiguration oder Abhängigkeiten. | +| `rustfs tls inspect --path ` | Prüft Layout und Parse-Status eines TLS-Zertifikatsverzeichnisses. | +| `rustfs diagnose [OPTIONS] ...` | Analysiert Protokolldateien und nennt wahrscheinliche Fehlerursachen. | +| `rustfs inspect ` | Ruft persistierte Bucket-Metadaten ohne laufenden Server ab. | +| `rustfs connect ` | Konfiguriert die ausgehende Integration RustFS Connect. | ```bash title="Examples" rustfs server /data/rustfs @@ -22,62 +22,62 @@ rustfs info --all --json rustfs tls inspect --path /etc/rustfs/tls ``` -### Legacy invocation compatibility +### Kompatibilität älterer Aufrufe -Arguments are preprocessed for backward compatibility, so older invocation styles keep working: +Argumente werden aus Gründen der Abwärtskompatibilität vorverarbeitet, damit ältere Aufrufformen weiterhin funktionieren: -| Legacy form | Interpreted as | +| Ältere Form | Wird interpretiert als | | --- | --- | | `rustfs /data` | `rustfs server /data` | | `rustfs --address :9000 /data` | `rustfs server --address :9000 /data` | -| `rustfs` (no arguments) | `rustfs server` with volumes read from `RUSTFS_VOLUMES` | +| `rustfs` (keine Argumente) | `rustfs server` mit Volumes aus `RUSTFS_VOLUMES` | | `rustfs --info` | `rustfs info` | | `rustfs help` | `rustfs --help` | -## Server flags +## Server-Flags -Every server flag has an environment variable equivalent; the flag wins when both are set. +Jedes Server-Flag hat eine äquivalente Umgebungsvariable. Wenn beide gesetzt sind, gilt das Flag. -| Flag | Environment variable | Default | Description | +| Flag | Umgebungsvariable | Standard | Beschreibung | | --- | --- | --- | --- | -| `...` (positional) | `RUSTFS_VOLUMES` | required | Storage volumes or endpoints, space-separated. | -| `--address` | `RUSTFS_ADDRESS` | `:9000` | S3 API bind address (`ADDRESS:PORT`, IP or hostname). | -| `--server-domains` | `RUSTFS_SERVER_DOMAINS` | unset | Comma-separated domains for virtual-hosted-style requests. | -| `--access-key` | `RUSTFS_ACCESS_KEY` | unset | Root access key (conflicts with `--access-key-file`). | -| `--access-key-file` | `RUSTFS_ACCESS_KEY_FILE` | unset | File containing the root access key. | -| `--secret-key` | `RUSTFS_SECRET_KEY` | unset | Root secret key (conflicts with `--secret-key-file`). | -| `--secret-key-file` | `RUSTFS_SECRET_KEY_FILE` | unset | File containing the root secret key. | -| `--console-enable` | `RUSTFS_CONSOLE_ENABLE` | `true` | Enable the embedded web console. | -| `--console-address` | `RUSTFS_CONSOLE_ADDRESS` | `:9001` | Console bind address. | -| `--obs-endpoint` | `RUSTFS_OBS_ENDPOINT` | empty | OTLP/HTTP base URL for traces, metrics, and logs. | -| `--tls-path` | `RUSTFS_TLS_PATH` | unset | TLS certificate directory for the API and console. | -| `--license` | `RUSTFS_LICENSE` | unset | License string. | -| `--region` | `RUSTFS_REGION` | unset | Service region reported to clients. | -| `--kms-enable` | `RUSTFS_KMS_ENABLE` | `false` | Enable KMS server-side encryption. | -| `--kms-backend` | `RUSTFS_KMS_BACKEND` | `local` | KMS backend: `local`, `vault` / `vault-kv2`, `vault-transit`. | -| `--kms-key-dir` | `RUSTFS_KMS_KEY_DIR` | unset | Key directory for the local KMS backend. | -| `--kms-local-master-key` | `RUSTFS_KMS_LOCAL_MASTER_KEY` | unset | Master key for local KMS key-file encryption. | -| `--kms-vault-address` | `RUSTFS_KMS_VAULT_ADDRESS` | unset | Vault address for the Vault backends. | -| `--kms-vault-token` | `RUSTFS_KMS_VAULT_TOKEN` | unset | Vault token for the Vault backends. | -| `--kms-vault-mount-path` | `RUSTFS_KMS_VAULT_MOUNT_PATH` | unset | Transit mount for `vault-transit` (defaults to `transit`); deprecated and unused for `vault` / `vault-kv2`. | -| `--kms-default-key-id` | `RUSTFS_KMS_DEFAULT_KEY_ID` | unset | Default KMS key ID for encryption. | -| `--kms-allow-insecure-dev-defaults` | `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS` | `false` | Allow development-only insecure KMS defaults. | -| `--buffer-profile` | `RUSTFS_BUFFER_PROFILE` | `GeneralPurpose` | Workload profile for adaptive buffer sizing. | -| `--buffer-profile-disable` | `RUSTFS_BUFFER_PROFILE_DISABLE` | `false` | Use legacy fixed-size buffers. | +| `...` (Positionsargument) | `RUSTFS_VOLUMES` | erforderlich | Speicher-Volumes oder Endpunkte, durch Leerzeichen getrennt. | +| `--address` | `RUSTFS_ADDRESS` | `:9000` | Bind-Adresse der S3-API (`ADDRESS:PORT`, IP oder Hostname). | +| `--server-domains` | `RUSTFS_SERVER_DOMAINS` | nicht gesetzt | Durch Kommas getrennte Domains für Anfragen mit Adressierung im Virtual-Hosted-Stil. | +| `--access-key` | `RUSTFS_ACCESS_KEY` | nicht gesetzt | Root-Zugriffsschlüssel (schließt `--access-key-file` aus). | +| `--access-key-file` | `RUSTFS_ACCESS_KEY_FILE` | nicht gesetzt | Datei mit dem Root-Zugriffsschlüssel. | +| `--secret-key` | `RUSTFS_SECRET_KEY` | nicht gesetzt | Geheimer Root-Zugriffsschlüssel (schließt `--secret-key-file` aus). | +| `--secret-key-file` | `RUSTFS_SECRET_KEY_FILE` | nicht gesetzt | Datei mit dem geheimen Root-Zugriffsschlüssel. | +| `--console-enable` | `RUSTFS_CONSOLE_ENABLE` | `true` | Aktiviert die eingebettete Console (Weboberfläche). | +| `--console-address` | `RUSTFS_CONSOLE_ADDRESS` | `:9001` | Bind-Adresse der Console. | +| `--obs-endpoint` | `RUSTFS_OBS_ENDPOINT` | leer | OTLP/HTTP-Basis-URL für Traces, Metriken und Protokolle. | +| `--tls-path` | `RUSTFS_TLS_PATH` | nicht gesetzt | TLS-Zertifikatsverzeichnis für API und Console. | +| `--license` | `RUSTFS_LICENSE` | nicht gesetzt | Lizenzzeichenkette. | +| `--region` | `RUSTFS_REGION` | nicht gesetzt | Region, die Clients als Dienstregion gemeldet wird. | +| `--kms-enable` | `RUSTFS_KMS_ENABLE` | `false` | Aktiviert die serverseitige Verschlüsselung über KMS. | +| `--kms-backend` | `RUSTFS_KMS_BACKEND` | `local` | KMS-Backend: `local`, `vault` / `vault-kv2`, `vault-transit`. | +| `--kms-key-dir` | `RUSTFS_KMS_KEY_DIR` | nicht gesetzt | Schlüsselverzeichnis für das lokale KMS-Backend. | +| `--kms-local-master-key` | `RUSTFS_KMS_LOCAL_MASTER_KEY` | nicht gesetzt | Hauptschlüssel für die Verschlüsselung lokaler KMS-Schlüsseldateien. | +| `--kms-vault-address` | `RUSTFS_KMS_VAULT_ADDRESS` | nicht gesetzt | Vault-Adresse für die Vault-Backends. | +| `--kms-vault-token` | `RUSTFS_KMS_VAULT_TOKEN` | nicht gesetzt | Vault-Token für die Vault-Backends. | +| `--kms-vault-mount-path` | `RUSTFS_KMS_VAULT_MOUNT_PATH` | nicht gesetzt | Transit-Mount für `vault-transit` (Standard `transit`); veraltet und ungenutzt für `vault` / `vault-kv2`. | +| `--kms-default-key-id` | `RUSTFS_KMS_DEFAULT_KEY_ID` | nicht gesetzt | Standard-KMS-Schlüssel-ID für die Verschlüsselung. | +| `--kms-allow-insecure-dev-defaults` | `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS` | `false` | Erlaubt unsichere KMS-Standards, die nur für die Entwicklung gedacht sind. | +| `--buffer-profile` | `RUSTFS_BUFFER_PROFILE` | `GeneralPurpose` | Lastprofil für die adaptive Puffergröße. | +| `--buffer-profile-disable` | `RUSTFS_BUFFER_PROFILE_DISABLE` | `false` | Verwendet feste Puffergrößen der älteren Implementierung. | :::note -If neither `--access-key`/`--secret-key` nor their file variants are provided, the server falls back to the built-in default credentials (`rustfsadmin`/`rustfsadmin`) and logs a warning. Set real credentials for any non-throwaway deployment. +Wenn weder `--access-key` und `--secret-key` noch die Dateivarianten angegeben sind, fällt der Server auf die eingebauten Standard-Anmeldedaten (`rustfsadmin`/`rustfsadmin`) zurück und protokolliert eine Warnung. Setzen Sie echte Anmeldedaten, sobald die Bereitstellung kein reiner Wegwerf-Test ist. ::: -## Volume syntax +## Volume-Syntax -Volumes are passed as positional arguments (or via `RUSTFS_VOLUMES`) and are space-separated. +Volumes werden als Positionsargumente übergeben (oder über `RUSTFS_VOLUMES`) und durch Leerzeichen getrennt. -### Ellipses expansion +### Ellipsen-Erweiterung -A volume token may contain one or more `{N...M}` ranges, which expand numerically: +Ein Volume-Token kann einen oder mehrere Bereiche `{N...M}` enthalten, die numerisch erweitert werden: ```bash title="Ellipses expansion" # Expands to /data/rustfs0 /data/rustfs1 /data/rustfs2 /data/rustfs3 @@ -87,21 +87,21 @@ rustfs server /data/rustfs{0...3} rustfs server http://node{1...4}:9000/data/rustfs{0...3} ``` -Rules verified from the parser: +Vom Parser geprüfte Regeln: -- The range format is `{N...M}` where `N` and `M` are decimal or hexadecimal positive integers and `M` must be greater than `N`. -- A single token may carry multiple ranges (e.g. host range plus disk range); all combinations are expanded. -- The maximum expanded size of one range is 10,000 entries. +- Das Bereichsformat ist `{N...M}`, wobei `N` und `M` positive Ganzzahlen in Dezimal- oder Hexadezimalform sind und `M` größer als `N` sein muss. +- Ein einzelnes Token kann mehrere Bereiche tragen (zum Beispiel Host-Bereich plus Laufwerksbereich); alle Kombinationen werden erweitert. +- Die maximale erweiterte Größe eines Bereichs beträgt 10.000 Einträge. -### Multiple pools +### Mehrere Pools -Separate server pools are expressed as space-separated groups of endpoints. Each argument (one per space) forms its own expansion group: +Getrennte Server-Pools geben Sie als durch Leerzeichen getrennte Gruppen von Endpunkten an. Jedes Argument (eines je Leerzeichen) bildet eine eigene Erweiterungsgruppe: ```bash title="Two pools" rustfs server http://node{1...4}:9000/data/rustfs{0...3} http://node{5...8}:9000/data/rustfs{0...3} ``` -When set through the environment, the same string goes into `RUSTFS_VOLUMES`: +Wenn Sie die Angabe über die Umgebung setzen, steht dieselbe Zeichenkette in `RUSTFS_VOLUMES`: ```bash title="Via environment" export RUSTFS_VOLUMES="http://node{1...4}:9000/data/rustfs{0...3}" diff --git a/content/de/reference/environment-variables.md b/content/de/reference/environment-variables.md index 9db713983..f4ab64d3d 100644 --- a/content/de/reference/environment-variables.md +++ b/content/de/reference/environment-variables.md @@ -1,201 +1,203 @@ --- -title: "Environment Variables" -description: "Reference for the environment variables that configure the RustFS server, console, TLS, KMS, observability, scanner, healing, storage classes, credentials, and event targets." +title: "Umgebungsvariablen" +description: "Referenz der Umgebungsvariablen, die Server, Console, TLS, KMS, Observability, Scanner, Datenwiederherstellung, Speicherklassen, Anmeldedaten und Ereignisziele von RustFS konfigurieren." --- -This page lists the environment variables recognized by the `rustfs` server binary. It covers the operations-relevant subset verified against the RustFS source code; some internal tuning knobs are intentionally omitted. Every variable can also be supplied through the matching command-line flag where one exists (see the [CLI reference](./cli)). +Diese Seite listet die Umgebungsvariablen, die das Server-Binary `rustfs` erkennt. Sie umfasst die betrieblich relevante Teilmenge, die gegen den Quellcode von RustFS geprüft wurde; einige interne Stellschrauben sind absichtlich ausgelassen. Jede Variable lässt sich auch über das passende Befehlszeilen-Flag setzen, sofern eines existiert (siehe die [CLI-Referenz](./cli)). -:::note[Boolean values] +:::note[Boolesche Werte] -Boolean variables accept `true`/`false`. Values shown as "unset" have no default and the corresponding feature stays disabled or falls back to built-in behavior. +Boolesche Variablen akzeptieren `true` und `false`. Als „nicht gesetzt“ angegebene Werte haben keinen Standard; die zugehörige Funktion bleibt deaktiviert oder fällt auf das eingebaute Verhalten zurück. ::: -## Core server +## Serverkern -| Variable | Default | Description | +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_VOLUMES` | unset (required) | Storage volumes or endpoints, space-separated. Supports `{N...M}` ellipses expansion, e.g. `/data/rustfs{0...3}` or `http://node{1...4}:9000/data/rustfs{0...3}`. The Docker image defaults to `/data`. | -| `RUSTFS_ADDRESS` | `:9000` | Bind address and port for the S3 API listener (also carries internal node RPC). | -| `RUSTFS_SERVER_DOMAINS` | unset | Comma-separated domain name(s) for virtual-hosted-style S3 requests, e.g. `s3.example.com` so `bucket.s3.example.com` resolves to bucket `bucket`. When unset, only path-style addressing works. | -| `RUSTFS_REGION` | unset | Region reported to S3 clients. When unset the server falls back to `us-east-1`. | -| `RUSTFS_LICENSE` | unset | License string. | -| `RUSTFS_BUFFER_PROFILE` | `GeneralPurpose` | Workload profile for adaptive buffer sizing. Options: `GeneralPurpose`, `AiTraining`, `DataAnalytics`, `WebWorkload`, `IndustrialIoT`, `SecureStorage`. | -| `RUSTFS_BUFFER_PROFILE_DISABLE` | `false` | Disable adaptive buffer sizing and use legacy fixed-size buffers. | -| `RUSTFS_HEALTH_ENDPOINT_ENABLE` | `true` | Register the unauthenticated `/health` and `/health/ready` probe endpoints. | -| `RUSTFS_HEALTH_READINESS_CACHE_TTL_MS` | `1000` | Cache TTL for readiness probe results, in milliseconds. | -| `RUSTFS_HEALTH_CLUSTER_TIMEOUT_MS` | `2000` | Timeout for cluster health probes (`/minio/health/cluster`), in milliseconds. | -| `RUSTFS_STARTUP_READINESS_MAX_WAIT_SECS` | `120` | Maximum time the readiness probe reports "starting" before startup is considered failed. | -| `RUSTFS_CHECK_UPDATE` | `true` | Check for a newer RustFS release at startup by sending one HTTPS request to `version.rustfs.com`; the user agent carries the current version. The result is logged only, and RustFS never updates itself. Set to `false` to skip the outbound request, for example in air-gapped deployments; unrecognized values fall back to `true`. | +| `RUSTFS_VOLUMES` | nicht gesetzt (erforderlich) | Speicher-Volumes oder Endpunkte, durch Leerzeichen getrennt. Unterstützt die Ellipsen-Erweiterung `{N...M}`, zum Beispiel `/data/rustfs{0...3}` oder `http://node{1...4}:9000/data/rustfs{0...3}`. Das Docker-Image verwendet standardmäßig `/data`. | +| `RUSTFS_ADDRESS` | `:9000` | Bind-Adresse und Port des Listeners der S3-API (trägt auch den internen Knoten-RPC). | +| `RUSTFS_SERVER_DOMAINS` | nicht gesetzt | Durch Kommas getrennte Domainnamen für S3-Anfragen mit Adressierung im Virtual-Hosted-Stil, zum Beispiel `s3.example.com`, sodass `bucket.s3.example.com` auf den Bucket `bucket` zeigt. Wenn die Variable nicht gesetzt ist, funktioniert nur die pfadbasierte Adressierung (Path-Style). | +| `RUSTFS_REGION` | nicht gesetzt | Region, die S3-Clients gemeldet wird. Wenn die Variable nicht gesetzt ist, fällt der Server auf `us-east-1` zurück. | +| `RUSTFS_LICENSE` | nicht gesetzt | Lizenzzeichenkette. | +| `RUSTFS_BUFFER_PROFILE` | `GeneralPurpose` | Lastprofil für die adaptive Puffergröße. Optionen: `GeneralPurpose`, `AiTraining`, `DataAnalytics`, `WebWorkload`, `IndustrialIoT`, `SecureStorage`. | +| `RUSTFS_BUFFER_PROFILE_DISABLE` | `false` | Deaktiviert die adaptive Puffergröße und verwendet feste Puffergrößen der älteren Implementierung. | +| `RUSTFS_HEALTH_ENDPOINT_ENABLE` | `true` | Registriert die nicht authentifizierten Integritätsendpunkte `/health` und `/health/ready`. | +| `RUSTFS_HEALTH_READINESS_CACHE_TTL_MS` | `1000` | Cache-TTL für Ergebnisse der Bereitschaftsprüfung, in Millisekunden. | +| `RUSTFS_HEALTH_CLUSTER_TIMEOUT_MS` | `2000` | Zeitüberschreitung für Cluster-Integritätsprüfungen (`/minio/health/cluster`), in Millisekunden. | +| `RUSTFS_STARTUP_READINESS_MAX_WAIT_SECS` | `120` | Maximale Zeit, in der die Bereitschaftsprüfung „starting“ meldet, bevor der Start als fehlgeschlagen gilt. | +| `RUSTFS_CHECK_UPDATE` | `true` | Prüft beim Start auf eine neuere RustFS-Version, indem eine HTTPS-Anfrage an `version.rustfs.com` gesendet wird; der User-Agent enthält die aktuelle Version. Das Ergebnis wird nur protokolliert, und RustFS aktualisiert sich nie selbst. Setzen Sie `false`, um die ausgehende Anfrage zu überspringen, zum Beispiel in Bereitstellungen ohne ausgehenden Netzzugriff. Nicht erkannte Werte fallen auf `true` zurück. | ## Console -| Variable | Default | Description | +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_CONSOLE_ENABLE` | `true` | Enable the embedded web console (served on a separate listener). | -| `RUSTFS_CONSOLE_ADDRESS` | `:9001` | Bind address and port for the console listener. | +| `RUSTFS_CONSOLE_ENABLE` | `true` | Aktiviert die eingebettete Console (Weboberfläche) auf einem eigenen Listener. | +| `RUSTFS_CONSOLE_ADDRESS` | `:9001` | Bind-Adresse und Port des Console-Listeners. | ## CORS -| Variable | Default | Description | +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_CORS_ALLOWED_ORIGINS` | empty | Comma-separated origins allowed to access the S3 API from a browser. Set `*` for wildcard origins without credentials. | -| `RUSTFS_CONSOLE_CORS_ALLOWED_ORIGINS` | `*` | Comma-separated origins allowed to access the Console from a browser, or `*` for all origins. | +| `RUSTFS_CORS_ALLOWED_ORIGINS` | leer | Durch Kommas getrennte Origins, die aus einem Browser auf die S3-API zugreifen dürfen. Setzen Sie `*` für Wildcard-Origins ohne mitgesendete Browser-Credentials. | +| `RUSTFS_CONSOLE_CORS_ALLOWED_ORIGINS` | `*` | Durch Kommas getrennte Origins, die aus einem Browser auf die Console zugreifen dürfen, oder `*` für alle Origins. | -See [CORS Configuration](/administration/cors) for configuration and verification steps. +Siehe [CORS-Konfiguration](/de/administration/cors) für Konfiguration und Prüfung. -## TLS & KMS +## TLS und KMS -| Variable | Default | Description | +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_TLS_PATH` | unset | Directory containing the TLS certificate and key (`rustfs_cert.pem` / `rustfs_key.pem`) for the S3 API and console. TLS is enabled when set. | -| `RUSTFS_TLS_RELOAD_ENABLE` | `false` | Watch the TLS directory and hot-reload certificates. | -| `RUSTFS_TLS_KEYLOG` | `false` | Write TLS session keys to a keylog file for debugging. Do not enable in production. | -| `RUSTFS_TRUST_SYSTEM_CA` | `false` | Also trust the operating system CA store for outbound TLS connections. | -| `RUSTFS_TRUST_LEAF_CERT_AS_CA` | `false` | Trust a leaf certificate as if it were a CA (self-signed setups). | -| `RUSTFS_SERVER_MTLS_ENABLE` | `false` | Require client certificates (mutual TLS) on the server listeners. | -| `RUSTFS_MTLS_CLIENT_CERT` | unset | Client certificate presented for internode mTLS connections. | -| `RUSTFS_MTLS_CLIENT_KEY` | unset | Client private key for internode mTLS connections. | -| `RUSTFS_KMS_ENABLE` | `false` | Enable KMS-backed server-side encryption. | -| `RUSTFS_KMS_BACKEND` | `local` | KMS backend: `local`, `vault` / `vault-kv2` (Vault KV2 storage with local data-key wrapping), or `vault-transit`. | -| `RUSTFS_KMS_KEY_DIR` | unset | Key directory for the `local` backend. | -| `RUSTFS_KMS_LOCAL_MASTER_KEY` | unset | Master key protecting local KMS key files. | -| `RUSTFS_KMS_VAULT_ADDRESS` | unset | Vault server address for the Vault backends. | -| `RUSTFS_KMS_VAULT_TOKEN` | unset | Vault token for the Vault backends. | -| `RUSTFS_KMS_VAULT_MOUNT_PATH` | `transit` | Transit mount for `vault-transit`; deprecated and unused for `vault` / `vault-kv2`. | -| `RUSTFS_KMS_VAULT_KV_MOUNT` | `secret` | KV v2 mount for the `vault` / `vault-kv2` backend. | -| `RUSTFS_KMS_VAULT_KEY_PREFIX` | `rustfs/kms/keys` | Key record prefix within the KV v2 mount for `vault` / `vault-kv2`. | -| `RUSTFS_KMS_DEFAULT_KEY_ID` | unset | Default KMS key ID used for encryption. | -| `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS` | `false` | Allow development-only insecure KMS defaults. Never enable in production. | +| `RUSTFS_TLS_PATH` | nicht gesetzt | Verzeichnis mit TLS-Zertifikat und Schlüssel (`rustfs_cert.pem` / `rustfs_key.pem`) für die S3-API und die Console. TLS ist aktiv, wenn die Variable gesetzt ist. | +| `RUSTFS_TLS_RELOAD_ENABLE` | `false` | Überwacht das TLS-Verzeichnis und lädt Zertifikate im laufenden Betrieb neu. | +| `RUSTFS_TLS_KEYLOG` | `false` | Schreibt TLS-Sitzungsschlüssel zu Diagnosezwecken in eine Keylog-Datei. Aktivieren Sie diese Option nicht in der Produktion. | +| `RUSTFS_TRUST_SYSTEM_CA` | `false` | Vertraut zusätzlich dem CA-Speicher des Betriebssystems für ausgehende TLS-Verbindungen. | +| `RUSTFS_TRUST_LEAF_CERT_AS_CA` | `false` | Vertraut einem Leaf-Zertifikat, als wäre es eine CA (selbst signierte Konfigurationen). | +| `RUSTFS_SERVER_MTLS_ENABLE` | `false` | Verlangt Client-Zertifikate (gegenseitiges TLS, mTLS) an den Server-Listenern. | +| `RUSTFS_MTLS_CLIENT_CERT` | nicht gesetzt | Client-Zertifikat für mTLS-Verbindungen zwischen Knoten. | +| `RUSTFS_MTLS_CLIENT_KEY` | nicht gesetzt | Privater Client-Schlüssel für mTLS-Verbindungen zwischen Knoten. | +| `RUSTFS_KMS_ENABLE` | `false` | Aktiviert die serverseitige Verschlüsselung über KMS. | +| `RUSTFS_KMS_BACKEND` | `local` | KMS-Backend: `local`, `vault` / `vault-kv2` (Vault-KV2-Speicher mit lokaler Umhüllung der Datenschlüssel) oder `vault-transit`. | +| `RUSTFS_KMS_KEY_DIR` | nicht gesetzt | Schlüsselverzeichnis für das Backend `local`. | +| `RUSTFS_KMS_LOCAL_MASTER_KEY` | nicht gesetzt | Hauptschlüssel, der lokale KMS-Schlüsseldateien schützt. | +| `RUSTFS_KMS_VAULT_ADDRESS` | nicht gesetzt | Vault-Serveradresse für die Vault-Backends. | +| `RUSTFS_KMS_VAULT_TOKEN` | nicht gesetzt | Vault-Token für die Vault-Backends. | +| `RUSTFS_KMS_VAULT_MOUNT_PATH` | `transit` | Transit-Mount für `vault-transit`; veraltet und ungenutzt für `vault` / `vault-kv2`. | +| `RUSTFS_KMS_VAULT_KV_MOUNT` | `secret` | KV-v2-Mount für das Backend `vault` / `vault-kv2`. | +| `RUSTFS_KMS_VAULT_KEY_PREFIX` | `rustfs/kms/keys` | Präfix der Schlüsseldatensätze im KV-v2-Mount für `vault` / `vault-kv2`. | +| `RUSTFS_KMS_DEFAULT_KEY_ID` | nicht gesetzt | Standard-KMS-Schlüssel-ID für die Verschlüsselung. | +| `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS` | `false` | Erlaubt unsichere KMS-Standards, die nur für die Entwicklung gedacht sind. Aktivieren Sie diese Option niemals in der Produktion. | ## Observability -The observability pipeline exports traces, metrics, and logs over OTLP/HTTP. +Die Observability-Pipeline exportiert Traces, Metriken und Protokolle über OTLP/HTTP. -| Variable | Default | Description | +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_OBS_ENDPOINT` | empty | Root OTLP/HTTP base URL for traces, metrics, and logs, e.g. `http://otel-collector:4318`. When empty, logs go to stdout or local files. | -| `RUSTFS_OBS_TRACE_ENDPOINT` | unset | Per-signal override for the traces endpoint. | -| `RUSTFS_OBS_METRIC_ENDPOINT` | unset | Per-signal override for the metrics endpoint. | -| `RUSTFS_OBS_LOG_ENDPOINT` | unset | Per-signal override for the logs endpoint. | -| `RUSTFS_OBS_TRACES_EXPORT_ENABLED` | `true` | Export traces to the OTLP endpoint. | -| `RUSTFS_OBS_METRICS_EXPORT_ENABLED` | `true` | Export metrics to the OTLP endpoint. | -| `RUSTFS_OBS_LOGS_EXPORT_ENABLED` | `true` | Export logs to the OTLP endpoint. | -| `RUSTFS_OBS_USE_STDOUT` | unset | Force telemetry output to stdout. | -| `RUSTFS_OBS_SAMPLE_RATIO` | unset | Trace sampling ratio (0.0–1.0). | -| `RUSTFS_OBS_METER_INTERVAL` | unset | Metrics export interval in seconds. | -| `RUSTFS_OBS_SERVICE_NAME` | unset | Service name reported in telemetry resource attributes. | -| `RUSTFS_OBS_ENVIRONMENT` | unset | Deployment environment label (`production`, `development`, `test`, `staging`). | -| `RUSTFS_OBS_LOGGER_LEVEL` | unset | Log level filter (e.g. `info`, `debug`). | -| `RUSTFS_OBS_LOG_STDOUT_ENABLED` | unset | Also mirror logs to stdout when file/OTLP logging is active. | -| `RUSTFS_OBS_LOG_DIRECTORY` | unset | Local log directory. Unset means logs go to stdout; a URL value sends logs to a remote endpoint. | -| `RUSTFS_OBS_LOG_FILENAME` | `rustfs.log` | Log filename inside the log directory. | -| `RUSTFS_OBS_LOG_ROTATION_TIME` | `hourly` | Time-based log rotation: `daily`, `hourly`, `minutely`. | -| `RUSTFS_OBS_LOG_KEEP_FILES` | `30` | Number of rotated log files to keep. | -| `RUSTFS_OBS_LOG_MAX_TOTAL_SIZE_BYTES` | `2147483648` | Total size budget (2 GiB) for the log directory before cleanup. | -| `RUSTFS_OBS_LOG_COMPRESS_OLD_FILES` | `true` | Compress rotated log files (`zstd` by default, controllable via `RUSTFS_OBS_LOG_COMPRESSION_ALGORITHM`). | - -Metrics collection intervals follow the pattern `RUSTFS_METRICS__INTERVAL_SEC` with scopes `DEFAULT`, `SYSTEM`, `CLUSTER`, `BUCKET`, `NODE`, `RESOURCE`, `AUDIT`, `NOTIFICATION`, and `BUCKET_REPLICATION_BANDWIDTH` — for example `RUSTFS_METRICS_CLUSTER_INTERVAL_SEC=60`. - -## Scanner & Healing - -| Variable | Default | Description | +| `RUSTFS_OBS_ENDPOINT` | leer | Basis-URL von OTLP/HTTP für Traces, Metriken und Protokolle, zum Beispiel `http://otel-collector:4318`. Wenn der Wert leer ist, gehen Protokolle nach stdout oder in lokale Dateien. | +| `RUSTFS_OBS_TRACE_ENDPOINT` | nicht gesetzt | Überschreibung des Trace-Endpunkts je Signal. | +| `RUSTFS_OBS_METRIC_ENDPOINT` | nicht gesetzt | Überschreibung des Metrik-Endpunkts je Signal. | +| `RUSTFS_OBS_LOG_ENDPOINT` | nicht gesetzt | Überschreibung des Protokoll-Endpunkts je Signal. | +| `RUSTFS_OBS_TRACES_EXPORT_ENABLED` | `true` | Exportiert Traces an den OTLP-Endpunkt. | +| `RUSTFS_OBS_METRICS_EXPORT_ENABLED` | `true` | Exportiert Metriken an den OTLP-Endpunkt. | +| `RUSTFS_OBS_LOGS_EXPORT_ENABLED` | `true` | Exportiert Protokolle an den OTLP-Endpunkt. | +| `RUSTFS_OBS_USE_STDOUT` | nicht gesetzt | Erzwingt die Telemetrieausgabe nach stdout. | +| `RUSTFS_OBS_SAMPLE_RATIO` | nicht gesetzt | Abtastrate für Traces (0.0–1.0). | +| `RUSTFS_OBS_METER_INTERVAL` | nicht gesetzt | Exportintervall für Metriken in Sekunden. | +| `RUSTFS_OBS_SERVICE_NAME` | nicht gesetzt | Dienstname in den Ressourcenattributen der Telemetrie. | +| `RUSTFS_OBS_ENVIRONMENT` | nicht gesetzt | Bezeichnung der Bereitstellungsumgebung (`production`, `development`, `test`, `staging`). | +| `RUSTFS_OBS_LOGGER_LEVEL` | nicht gesetzt | Filter für die Protokollstufe (zum Beispiel `info`, `debug`). | +| `RUSTFS_OBS_LOG_STDOUT_ENABLED` | nicht gesetzt | Spiegelt Protokolle zusätzlich nach stdout, wenn Datei- oder OTLP-Protokollierung aktiv ist. | +| `RUSTFS_OBS_LOG_DIRECTORY` | nicht gesetzt | Lokales Protokollverzeichnis. Nicht gesetzt bedeutet Ausgabe nach stdout; ein URL-Wert sendet Protokolle an einen entfernten Endpunkt. | +| `RUSTFS_OBS_LOG_FILENAME` | `rustfs.log` | Protokolldateiname im Protokollverzeichnis. | +| `RUSTFS_OBS_LOG_ROTATION_TIME` | `hourly` | Zeitbasierte Protokollrotation: `daily`, `hourly`, `minutely`. | +| `RUSTFS_OBS_LOG_KEEP_FILES` | `30` | Anzahl der aufbewahrten rotierten Protokolldateien. | +| `RUSTFS_OBS_LOG_MAX_TOTAL_SIZE_BYTES` | `2147483648` | Gesamtbudget (2 GiB) für das Protokollverzeichnis vor der Bereinigung. | +| `RUSTFS_OBS_LOG_COMPRESS_OLD_FILES` | `true` | Komprimiert rotierte Protokolldateien (standardmäßig `zstd`, steuerbar über `RUSTFS_OBS_LOG_COMPRESSION_ALGORITHM`). | + +Intervalle der Metrikerfassung folgen dem Muster `RUSTFS_METRICS__INTERVAL_SEC` mit den Bereichen `DEFAULT`, `SYSTEM`, `CLUSTER`, `BUCKET`, `NODE`, `RESOURCE`, `AUDIT`, `NOTIFICATION` und `BUCKET_REPLICATION_BANDWIDTH`, zum Beispiel `RUSTFS_METRICS_CLUSTER_INTERVAL_SEC=60`. + +## Scanner und Datenwiederherstellung (Healing) + +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_SCANNER_SPEED` | `default` | Scanner speed preset: `fastest`, `fast`, `default`, `slow`, `slowest`. Controls sleep factor, max sleep, and cycle interval. | -| `RUSTFS_SCANNER_DELAY` | preset | Overrides the scanner sleep multiplier (e.g. `30.0`). | -| `RUSTFS_SCANNER_MAX_WAIT_SECS` | preset | Overrides the maximum scanner sleep in seconds. | -| `RUSTFS_SCANNER_CYCLE` | preset | Overrides the scan cycle interval in seconds (e.g. `3600`). | -| `RUSTFS_SCANNER_START_DELAY_SECS` | unset | Startup delay in seconds before the first scan cycle. | -| `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` | `1800` | Caps one cycle's runtime in seconds; `0` disables the budget. | -| `RUSTFS_SCANNER_CYCLE_MAX_OBJECTS` | `0` | Caps objects processed per cycle; `0` disables the budget. | -| `RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES` | `0` | Caps directories entered per cycle; `0` disables the budget. | -| `RUSTFS_SCANNER_BITROT_CYCLE_SECS` | `2592000` | Periodic deep (bitrot) scan cycle in seconds (30 days). `0`/`true`/`on` makes every cycle deep; `false`/`off` disables deep scans. | -| `RUSTFS_SCANNER_IDLE_MODE` | `true` | When `true` the scanner throttles itself; `false` runs at full speed. | -| `RUSTFS_SCANNER_CACHE_SAVE_TIMEOUT_SECS` | `14` | Scanner cache save timeout in seconds (minimum `1`). | -| `RUSTFS_SCANNER_MAX_CONCURRENT_SET_SCANS` | `4` | Caps concurrent erasure-set scan tasks; `0` keeps topology-based concurrency. | -| `RUSTFS_SCANNER_MAX_CONCURRENT_DISK_SCANS` | `4` | Caps concurrent disk bucket walks per set; `0` keeps disk-count-based concurrency. | -| `RUSTFS_SCANNER_YIELD_EVERY_N_OBJECTS` | `128` | How often scanner object loops yield to the async runtime; `0` disables the extra yield. | -| `RUSTFS_SCANNER_ALERT_EXCESS_VERSIONS` | `100` | Object version count that triggers scanner alerts. | -| `RUSTFS_SCANNER_ALERT_EXCESS_VERSION_SIZE` | `1099511627776` | Cumulative version bytes (1 TiB) that trigger scanner alerts. | -| `RUSTFS_SCANNER_ALERT_EXCESS_FOLDERS` | `65538` | Direct subfolder count that triggers scanner alerts. | -| `RUSTFS_HEAL_AUTO_HEAL_ENABLE` | `true` | Enable automatic background healing of degraded objects. | -| `RUSTFS_HEAL_QUEUE_SIZE` | `10000` | Capacity of the heal-candidate queue. | -| `RUSTFS_HEAL_INTERVAL_SECS` | `10` | Interval between heal scheduler runs, in seconds. | -| `RUSTFS_HEAL_TASK_TIMEOUT_SECS` | `300` | Timeout for a single heal task, in seconds. | -| `RUSTFS_HEAL_MAX_CONCURRENT_HEALS` | `4` | Maximum concurrent heal tasks. | -| `RUSTFS_HEAL_MAX_CONCURRENT_PER_SET` | `1` | Maximum concurrent heal tasks per erasure set. | - -## Storage & Erasure - -| Variable | Default | Description | +| `RUSTFS_SCANNER_SPEED` | `default` | Vorgabe für die Scanner-Geschwindigkeit: `fastest`, `fast`, `default`, `slow`, `slowest`. Steuert Schlaffaktor, maximale Pause und Zyklusintervall. | +| `RUSTFS_SCANNER_DELAY` | aus der Geschwindigkeitsvorgabe | Überschreibt den Schlaf-Multiplikator des Scanners (zum Beispiel `30.0`). | +| `RUSTFS_SCANNER_MAX_WAIT_SECS` | aus der Geschwindigkeitsvorgabe | Überschreibt die maximale Scanner-Pause in Sekunden. | +| `RUSTFS_SCANNER_CYCLE` | aus der Geschwindigkeitsvorgabe | Überschreibt das Scan-Zyklusintervall in Sekunden (zum Beispiel `3600`). | +| `RUSTFS_SCANNER_START_DELAY_SECS` | nicht gesetzt | Startverzögerung in Sekunden vor dem ersten Scan-Zyklus. | +| `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` | `1800` | Begrenzt die Laufzeit eines Zyklus in Sekunden; `0` hebt das Budget auf. | +| `RUSTFS_SCANNER_CYCLE_MAX_OBJECTS` | `0` | Begrenzt die je Zyklus verarbeiteten Objekte; `0` hebt das Budget auf. | +| `RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES` | `0` | Begrenzt die je Zyklus betretenen Verzeichnisse; `0` hebt das Budget auf. | +| `RUSTFS_SCANNER_BITROT_CYCLE_SECS` | `2592000` | Zyklus des periodischen tiefen Scans (Bitrot) in Sekunden (30 Tage). `0`, `true` oder `on` macht jeden Zyklus tief; `false` oder `off` deaktiviert tiefe Scans. | +| `RUSTFS_SCANNER_IDLE_MODE` | `true` | Bei `true` drosselt sich der Scanner selbst; `false` lässt ihn mit voller Geschwindigkeit laufen. | +| `RUSTFS_SCANNER_CACHE_SAVE_TIMEOUT_SECS` | `14` | Zeitüberschreitung für das Speichern des Scanner-Caches in Sekunden (Minimum `1`). | +| `RUSTFS_SCANNER_MAX_CONCURRENT_SET_SCANS` | `4` | Begrenzt die Anzahl gleichzeitiger Scan-Aufgaben für Erasure-Sets; `0` behält die aus der Topologie abgeleitete Nebenläufigkeit. | +| `RUSTFS_SCANNER_MAX_CONCURRENT_DISK_SCANS` | `4` | Begrenzt gleichzeitige Bucket-Durchläufe auf Festplatten je Set; `0` behält die aus der Festplattenanzahl abgeleitete Nebenläufigkeit. | +| `RUSTFS_SCANNER_YIELD_EVERY_N_OBJECTS` | `128` | Wie oft Objektschleifen des Scanners an die asynchrone Laufzeitumgebung abgeben; `0` deaktiviert die zusätzliche Abgabe. | +| `RUSTFS_SCANNER_ALERT_EXCESS_VERSIONS` | `100` | Anzahl der Objektversionen, die Scanner-Alarme auslöst. | +| `RUSTFS_SCANNER_ALERT_EXCESS_VERSION_SIZE` | `1099511627776` | Aufsummierte Versionsbytes (1 TiB), die Scanner-Alarme auslösen. | +| `RUSTFS_SCANNER_ALERT_EXCESS_FOLDERS` | `65538` | Anzahl direkter Unterordner, die Scanner-Alarme auslöst. | +| `RUSTFS_HEAL_AUTO_HEAL_ENABLE` | `true` | Aktiviert die automatische Datenwiederherstellung beeinträchtigter Objekte im Hintergrund. | +| `RUSTFS_HEAL_QUEUE_SIZE` | `10000` | Kapazität der Warteschlange für Kandidaten der Datenwiederherstellung. | +| `RUSTFS_HEAL_INTERVAL_SECS` | `10` | Abstand zwischen den Läufen des Planers für die Datenwiederherstellung, in Sekunden. | +| `RUSTFS_HEAL_TASK_TIMEOUT_SECS` | `300` | Zeitüberschreitung für eine einzelne Aufgabe der Datenwiederherstellung, in Sekunden. | +| `RUSTFS_HEAL_MAX_CONCURRENT_HEALS` | `4` | Maximale Anzahl gleichzeitiger Aufgaben der Datenwiederherstellung. | +| `RUSTFS_HEAL_MAX_CONCURRENT_PER_SET` | `1` | Maximale Anzahl gleichzeitiger Aufgaben der Datenwiederherstellung je Erasure-Set. | + +## Speicher und Erasure Coding + +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_STORAGE_CLASS_STANDARD` | auto | Parity for the STANDARD storage class in `EC:n` format, e.g. `EC:4`. When unset, parity is derived from the erasure set size. | -| `RUSTFS_STORAGE_CLASS_RRS` | `EC:1` | Parity for the REDUCED_REDUNDANCY storage class in `EC:n` format. | -| `RUSTFS_STORAGE_CLASS_OPTIMIZE` | `availability` | Optimization goal for parity selection. | -| `RUSTFS_STORAGE_CLASS_INLINE_BLOCK` | `131072` | Threshold (128 KiB) below which object data is inlined into metadata. | -| `RUSTFS_ERASURE_SET_DRIVE_COUNT` | `0` | Force the number of drives per erasure set; `0` selects the layout automatically. | -| `RUSTFS_DURABILITY_MODE` | unset | Write durability mode: `strict`, `relaxed`, or `none`. Takes precedence over the legacy drive-sync switch when set to a valid value. | +| `RUSTFS_STORAGE_CLASS_STANDARD` | automatisch | Parität der Speicherklasse STANDARD im Format `EC:n`, zum Beispiel `EC:4`. Wenn die Variable nicht gesetzt ist, wird die Parität aus der Größe des Erasure-Sets abgeleitet. | +| `RUSTFS_STORAGE_CLASS_RRS` | `EC:1` | Parität der Speicherklasse REDUCED_REDUNDANCY im Format `EC:n`. | +| `RUSTFS_STORAGE_CLASS_OPTIMIZE` | `availability` | Optimierungsziel bei der Wahl der Parität. | +| `RUSTFS_STORAGE_CLASS_INLINE_BLOCK` | `131072` | Schwellenwert (128 KiB), unter dem Objektdaten in die Metadaten eingebettet werden. | +| `RUSTFS_ERASURE_SET_DRIVE_COUNT` | `0` | Erzwingt die Anzahl der Laufwerke je Erasure-Set; `0` wählt das Layout automatisch. | +| `RUSTFS_DURABILITY_MODE` | nicht gesetzt | Modus der Schreibdauerhaftigkeit: `strict`, `relaxed` oder `none`. Hat Vorrang vor dem älteren Schalter für die Laufwerksynchronisierung, wenn ein gültiger Wert gesetzt ist. | -## Credentials & Internal +## Anmeldedaten und interne Einstellungen -| Variable | Default | Description | +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_ACCESS_KEY` | `rustfsadmin` | Root access key. Mutually exclusive with `RUSTFS_ACCESS_KEY_FILE`. | -| `RUSTFS_SECRET_KEY` | `rustfsadmin` | Root secret key. Mutually exclusive with `RUSTFS_SECRET_KEY_FILE`. | -| `RUSTFS_ACCESS_KEY_FILE` | unset | Path to a file containing the access key (e.g. a Docker/Kubernetes secret mount). | -| `RUSTFS_SECRET_KEY_FILE` | unset | Path to a file containing the secret key. | -| `RUSTFS_RPC_SECRET` | derived | Secret used to authenticate internode RPC. When unset it is derived from the active access/secret key pair; with an all-default credential pair, multi-node clusters must set it explicitly. | +| `RUSTFS_ACCESS_KEY` | `rustfsadmin` | Root-Zugriffsschlüssel. Schließt sich mit `RUSTFS_ACCESS_KEY_FILE` gegenseitig aus. | +| `RUSTFS_SECRET_KEY` | `rustfsadmin` | Geheimer Root-Zugriffsschlüssel. Schließt sich mit `RUSTFS_SECRET_KEY_FILE` gegenseitig aus. | +| `RUSTFS_ACCESS_KEY_FILE` | nicht gesetzt | Pfad zu einer Datei mit dem Zugriffsschlüssel (zum Beispiel ein Secret-Mount von Docker oder Kubernetes). | +| `RUSTFS_SECRET_KEY_FILE` | nicht gesetzt | Pfad zu einer Datei mit dem geheimen Zugriffsschlüssel. | +| `RUSTFS_RPC_SECRET` | abgeleitet | Geheimnis für die Authentifizierung von RPC zwischen Knoten. Wenn die Variable nicht gesetzt ist, wird sie aus dem aktiven Paar aus Zugriffsschlüssel und geheimem Zugriffsschlüssel abgeleitet. Bei einem vollständig standardmäßigen Anmeldedatenpaar müssen Cluster mit mehreren Knoten sie ausdrücklich setzen. | :::warning -The built-in default credentials `rustfsadmin`/`rustfsadmin` are for first-boot convenience only. Always set non-default credentials for production deployments. +Die eingebauten Standard-Anmeldedaten `rustfsadmin`/`rustfsadmin` dienen nur der Bequemlichkeit beim ersten Start. Setzen Sie für Produktionsbereitstellungen immer Anmeldedaten, die vom Standard abweichen. ::: -## Event & Audit targets + -Module switches: +## Ereignis- und Audit-Ziele -| Variable | Default | Description | +Modulschalter: + +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_NOTIFY_ENABLE` | `false` | Enable the bucket event notification module. | -| `RUSTFS_AUDIT_ENABLE` | `false` | Enable the audit logging module. | +| `RUSTFS_NOTIFY_ENABLE` | `false` | Aktiviert das Modul für Bucket-Ereignisbenachrichtigungen. | +| `RUSTFS_AUDIT_ENABLE` | `false` | Aktiviert das Modul für die Audit-Protokollierung. | -Target configuration is pattern-based: `RUSTFS_NOTIFY__` for event notification and `RUSTFS_AUDIT__` for audit logs. Supported targets in both families: `WEBHOOK`, `KAFKA`, `MQTT`, `MYSQL`, `POSTGRES`, `NATS`, `REDIS`, `AMQP`, `PULSAR`. +Die Zielkonfiguration folgt einem Muster: `RUSTFS_NOTIFY__` für Ereignisbenachrichtigungen und `RUSTFS_AUDIT__` für Audit-Protokolle. Unterstützte Ziele in beiden Familien: `WEBHOOK`, `KAFKA`, `MQTT`, `MYSQL`, `POSTGRES`, `NATS`, `REDIS`, `AMQP`, `PULSAR`. -Sub-keys for the webhook target (the same keys exist under `RUSTFS_AUDIT_WEBHOOK_*`): +Unterschlüssel für das Webhook-Ziel (dieselben Schlüssel gibt es unter `RUSTFS_AUDIT_WEBHOOK_*`): -| Variable | Default | Description | +| Variable | Standard | Beschreibung | | --- | --- | --- | -| `RUSTFS_NOTIFY_WEBHOOK_ENABLE` | `false` | Enable the webhook target. | -| `RUSTFS_NOTIFY_WEBHOOK_ENDPOINT` | unset | Webhook HTTP(S) endpoint URL. | -| `RUSTFS_NOTIFY_WEBHOOK_AUTH_TOKEN` | unset | Bearer token sent with each delivery. | -| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_DIR` | unset | Directory for the persistent delivery queue. | -| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_LIMIT` | unset | Maximum queued events. | -| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CERT` | unset | Client certificate for mTLS to the endpoint. | -| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_KEY` | unset | Client private key for mTLS to the endpoint. | -| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CA` | unset | CA certificate used to verify the endpoint. | -| `RUSTFS_NOTIFY_WEBHOOK_SKIP_TLS_VERIFY` | unset | Skip TLS verification of the endpoint (not recommended). | +| `RUSTFS_NOTIFY_WEBHOOK_ENABLE` | `false` | Aktiviert das Webhook-Ziel. | +| `RUSTFS_NOTIFY_WEBHOOK_ENDPOINT` | nicht gesetzt | HTTP(S)-Endpunkt-URL des Webhooks. | +| `RUSTFS_NOTIFY_WEBHOOK_AUTH_TOKEN` | nicht gesetzt | Bearer-Token, das bei jeder Zustellung gesendet wird. | +| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_DIR` | nicht gesetzt | Verzeichnis für die persistente Zustellungswarteschlange. | +| `RUSTFS_NOTIFY_WEBHOOK_QUEUE_LIMIT` | nicht gesetzt | Maximale Anzahl wartender Ereignisse. | +| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CERT` | nicht gesetzt | Client-Zertifikat für mTLS zum Endpunkt. | +| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_KEY` | nicht gesetzt | Privater Client-Schlüssel für mTLS zum Endpunkt. | +| `RUSTFS_NOTIFY_WEBHOOK_CLIENT_CA` | nicht gesetzt | CA-Zertifikat, mit dem der Endpunkt geprüft wird. | +| `RUSTFS_NOTIFY_WEBHOOK_SKIP_TLS_VERIFY` | nicht gesetzt | Überspringt die TLS-Prüfung des Endpunkts (nicht empfohlen). | -Other targets follow the same shape with target-specific keys, e.g. `RUSTFS_NOTIFY_KAFKA_BROKERS`, `RUSTFS_NOTIFY_KAFKA_TOPIC`, `RUSTFS_NOTIFY_MQTT_BROKER`, `RUSTFS_NOTIFY_MQTT_TOPIC`, `RUSTFS_NOTIFY_MYSQL_DSN_STRING`, `RUSTFS_NOTIFY_NATS_ADDRESS`, `RUSTFS_NOTIFY_REDIS_URL`, `RUSTFS_NOTIFY_AMQP_URL`, `RUSTFS_NOTIFY_PULSAR_BROKER`. +Andere Ziele folgen demselben Muster mit zielspezifischen Schlüsseln, zum Beispiel `RUSTFS_NOTIFY_KAFKA_BROKERS`, `RUSTFS_NOTIFY_KAFKA_TOPIC`, `RUSTFS_NOTIFY_MQTT_BROKER`, `RUSTFS_NOTIFY_MQTT_TOPIC`, `RUSTFS_NOTIFY_MYSQL_DSN_STRING`, `RUSTFS_NOTIFY_NATS_ADDRESS`, `RUSTFS_NOTIFY_REDIS_URL`, `RUSTFS_NOTIFY_AMQP_URL`, `RUSTFS_NOTIFY_PULSAR_BROKER`. -## Legacy compatibility +## Abwärtskompatibilität -### MINIO_* variable mapping +### Zuordnung von `MINIO_*`-Variablen -For migration convenience, RustFS maps a fixed allowlist of `MINIO_*` variables to their `RUSTFS_*` equivalents at startup: +Zur Vereinfachung der Migration ordnet RustFS beim Start eine feste Positivliste von `MINIO_*`-Variablen ihren `RUSTFS_*`-Entsprechungen zu: -- If only the `MINIO_`-prefixed variable is set, its value is used and a deprecation warning is logged. -- If both `MINIO_*` and `RUSTFS_*` are set with different values, the `RUSTFS_*` value wins and a conflict is recorded. +- Wenn nur die Variable mit dem Präfix `MINIO_` gesetzt ist, wird ihr Wert verwendet und eine Veraltungswarnung protokolliert. +- Wenn sowohl `MINIO_*` als auch `RUSTFS_*` mit unterschiedlichen Werten gesetzt sind, gilt der Wert von `RUSTFS_*` und der Konflikt wird festgehalten. -The mapped suffixes include `ACCESS_KEY`, `SECRET_KEY`, `ACCESS_KEY_FILE`, `SECRET_KEY_FILE`, `ROOT_USER`, `ROOT_PASSWORD`, `ADDRESS`, `CONSOLE_ADDRESS`, `VOLUMES`, `REGION`, `LICENSE`, `ERASURE_SET_DRIVE_COUNT`, `STORAGE_CLASS_STANDARD`, `STORAGE_CLASS_RRS`, `STORAGE_CLASS_OPTIMIZE`, `STORAGE_CLASS_INLINE_BLOCK`, `SCANNER_SPEED`, `SCANNER_CYCLE`, `COMPRESS_ENABLE`, `COMPRESS_EXTENSIONS`, `COMPRESS_MIME_TYPES`, `DRIVE_ACTIVE_MONITORING`, `ILM_EXPIRATION_WORKERS`, `API_XFF_HEADER`, `POLICY_PLUGIN_URL`, `POLICY_PLUGIN_AUTH_TOKEN`, the `IDENTITY_OPENID_*` keys, and every variable starting with `NOTIFY_WEBHOOK_`, `NOTIFY_MQTT_`, `AUDIT_WEBHOOK_`, or `AUDIT_MQTT_`. For example, `MINIO_ROOT_USER` maps to `RUSTFS_ROOT_USER` and `MINIO_NOTIFY_WEBHOOK_ENDPOINT` maps to `RUSTFS_NOTIFY_WEBHOOK_ENDPOINT`. +Die zugeordneten Suffixe umfassen `ACCESS_KEY`, `SECRET_KEY`, `ACCESS_KEY_FILE`, `SECRET_KEY_FILE`, `ROOT_USER`, `ROOT_PASSWORD`, `ADDRESS`, `CONSOLE_ADDRESS`, `VOLUMES`, `REGION`, `LICENSE`, `ERASURE_SET_DRIVE_COUNT`, `STORAGE_CLASS_STANDARD`, `STORAGE_CLASS_RRS`, `STORAGE_CLASS_OPTIMIZE`, `STORAGE_CLASS_INLINE_BLOCK`, `SCANNER_SPEED`, `SCANNER_CYCLE`, `COMPRESS_ENABLE`, `COMPRESS_EXTENSIONS`, `COMPRESS_MIME_TYPES`, `DRIVE_ACTIVE_MONITORING`, `ILM_EXPIRATION_WORKERS`, `API_XFF_HEADER`, `POLICY_PLUGIN_URL`, `POLICY_PLUGIN_AUTH_TOKEN`, die Schlüssel `IDENTITY_OPENID_*` und jede Variable, die mit `NOTIFY_WEBHOOK_`, `NOTIFY_MQTT_`, `AUDIT_WEBHOOK_` oder `AUDIT_MQTT_` beginnt. Zum Beispiel wird `MINIO_ROOT_USER` auf `RUSTFS_ROOT_USER` und `MINIO_NOTIFY_WEBHOOK_ENDPOINT` auf `RUSTFS_NOTIFY_WEBHOOK_ENDPOINT` abgebildet. -### Deprecated aliases +### Veraltete Aliase -| Deprecated variable | Use instead | +| Veraltete Variable | Stattdessen verwenden | | --- | --- | | `RUSTFS_ROOT_USER` | `RUSTFS_ACCESS_KEY` | | `RUSTFS_ROOT_PASSWORD` | `RUSTFS_SECRET_KEY` | | `RUSTFS_DATA_SCANNER_START_DELAY_SECS` | `RUSTFS_SCANNER_START_DELAY_SECS` | -Deprecated aliases still work but log a warning; the canonical `RUSTFS_*` name always takes precedence when both are set. +Veraltete Aliase funktionieren weiterhin, protokollieren aber eine Warnung. Der kanonische Name `RUSTFS_*` hat immer Vorrang, wenn beide gesetzt sind. diff --git a/content/de/reference/index.md b/content/de/reference/index.md index 8bcb95e50..c1df4faa3 100644 --- a/content/de/reference/index.md +++ b/content/de/reference/index.md @@ -1,11 +1,11 @@ --- -title: "Reference" -description: "Look up RustFS configuration variables and command-line options." +title: "Referenz" +description: "Schlagen Sie Konfigurationsvariablen und Befehlszeilenoptionen von RustFS nach." --- -Use this section for concise technical references while configuring, operating, or integrating RustFS. +Nutzen Sie diesen Abschnitt als knappe technische Referenz, wenn Sie RustFS konfigurieren, betreiben oder integrieren. -## References +## Referenzen -- [Environment Variables](./environment-variables.md) -- [CLI](./cli.md) \ No newline at end of file +- [Umgebungsvariablen](./environment-variables.md) +- [CLI](./cli.md) diff --git a/content/de/security-compliance/audit-logs.md b/content/de/security-compliance/audit-logs.md index 593410ac2..2409329f1 100644 --- a/content/de/security-compliance/audit-logs.md +++ b/content/de/security-compliance/audit-logs.md @@ -1,28 +1,28 @@ --- -title: "Audit Targets" -description: "Configure RustFS audit targets and deliver request-level audit records to external systems." +title: "Audit-Ziele" +description: "Konfigurieren Sie Audit-Ziele in RustFS und übermitteln Sie Audit-Datensätze auf Anfrageebene an externe Systeme." --- -RustFS Audit Targets send request-level activity records to external systems for security monitoring, compliance, and incident investigation. This guide configures a webhook target and verifies audit delivery with an S3 request. +Audit-Ziele in RustFS senden Aktivitätsdatensätze auf Anfrageebene an externe Systeme für Sicherheitsüberwachung, Compliance und die Untersuchung von Vorfällen. In dieser Anleitung konfigurieren Sie ein Webhook-Ziel und prüfen die Audit-Zustellung mit einer S3-Anfrage. -## Overview +## Überblick -Audit Targets and Event Notifications serve different purposes: +Audit-Ziele und Ereignisbenachrichtigungen erfüllen unterschiedliche Zwecke: -| Feature | Audit Targets | Event Notifications | +| Funktion | Audit-Ziele | Ereignisbenachrichtigungen | | --- | --- | --- | -| Scope | Request and API activity across RustFS | Events selected by each bucket configuration | -| Routing | Every enabled audit target receives audit records | Each bucket rule selects a target | -| Filtering | No per-target event filter | Event, prefix, and suffix filters | -| Typical use | Security information and event management (SIEM), compliance, investigation | Application workflows and data pipelines | +| Umfang | Anfrage- und API-Aktivität in ganz RustFS | Ereignisse, die die jeweilige Bucket-Konfiguration auswählt | +| Weiterleitung | Jedes aktivierte Audit-Ziel erhält Audit-Datensätze | Jede Bucket-Regel wählt ein Ziel | +| Filterung | Kein Ereignisfilter je Ziel | Filter für Ereignis, Präfix und Suffix | +| Typische Verwendung | Sicherheitsinformations- und Ereignismanagement (SIEM), Compliance, Untersuchung | Anwendungsabläufe und Datenpipelines | -RustFS supports webhook, Kafka, MQTT, MySQL, PostgreSQL, NATS, Redis, AMQP, and Pulsar audit target families. Each enabled target receives the audit stream independently. +RustFS unterstützt die Audit-Ziel-Familien Webhook, Kafka, MQTT, MySQL, PostgreSQL, NATS, Redis, AMQP und Pulsar. Jedes aktivierte Ziel erhält den Audit-Strom unabhängig. -Audit records can contain request paths, query parameters, selected headers, identity claims, access-key identifiers, remote hosts, user agents, response status, and errors. Protect the destination and restrict access according to your retention and compliance requirements. +Audit-Datensätze können Anfragepfade, Abfrageparameter, ausgewählte Header, Identitäts-Claims, Kennungen von Zugriffsschlüsseln, entfernte Hosts, User-Agents, den Antwortstatus und Fehler enthalten. Schützen Sie das Ziel und beschränken Sie den Zugriff entsprechend Ihren Aufbewahrungs- und Compliance-Anforderungen. -## Configuration +## Konfiguration -Audit delivery is disabled by default. The following environment variables enable the module and create a webhook target named `primary`: +Die Audit-Zustellung ist standardmäßig deaktiviert. Die folgenden Umgebungsvariablen aktivieren das Modul und legen ein Webhook-Ziel mit dem Namen `primary` an: ```bash export RUSTFS_AUDIT_ENABLE="true" @@ -33,69 +33,69 @@ export RUSTFS_AUDIT_WEBHOOK_QUEUE_DIR_PRIMARY="/var/lib/rustfs/audit-primary" export RUSTFS_OUTBOUND_ALLOW_ORIGINS="https://audit.example.com" ``` -Restart RustFS after changing environment-managed targets. The target name is the lowercase form of the environment-variable suffix, so `_PRIMARY` creates `primary`. +Starten Sie RustFS neu, nachdem Sie Ziele geändert haben, die über Umgebungsvariablen verwaltet werden. Der Zielname ist die kleingeschriebene Form des Suffixes der Umgebungsvariable. `_PRIMARY` erzeugt daher `primary`. -RustFS sends a `HEAD` health check to the endpoint origin's root path, such as `https://audit.example.com/`, and sends JSON `POST` requests to the complete configured endpoint. The origin must respond to `HEAD`, while delivery requests must return a successful HTTP status. Allow the RustFS service account to write to the queue directory. +RustFS sendet eine Integritätsprüfung per `HEAD` an den Wurzelpfad des Endpunkt-Origins, zum Beispiel `https://audit.example.com/`, und sendet JSON-`POST`-Anfragen an den vollständig konfigurierten Endpunkt. Der Origin muss auf `HEAD` antworten, Zustellanfragen müssen einen erfolgreichen HTTP-Status zurückgeben. Erlauben Sie dem Dienstkonto von RustFS, in das Warteschlangenverzeichnis zu schreiben. -### Webhook settings +### Webhook-Einstellungen -Use the same `_PRIMARY` suffix on all settings for this target: +Verwenden Sie für alle Einstellungen dieses Ziels dasselbe Suffix `_PRIMARY`: -| Variable | Purpose | +| Variable | Zweck | | --- | --- | -| `RUSTFS_AUDIT_WEBHOOK_ENDPOINT_PRIMARY` | HTTP or HTTPS delivery endpoint | -| `RUSTFS_AUDIT_WEBHOOK_AUTH_TOKEN_PRIMARY` | Bearer token sent in the `Authorization` header | -| `RUSTFS_AUDIT_WEBHOOK_QUEUE_DIR_PRIMARY` | Directory for queued audit records | -| `RUSTFS_AUDIT_WEBHOOK_QUEUE_LIMIT_PRIMARY` | Maximum number of queued records | -| `RUSTFS_AUDIT_WEBHOOK_CLIENT_CERT_PRIMARY` | Client certificate for mutual TLS (mTLS) | -| `RUSTFS_AUDIT_WEBHOOK_CLIENT_KEY_PRIMARY` | Private key paired with the client certificate | -| `RUSTFS_AUDIT_WEBHOOK_CLIENT_CA_PRIMARY` | Certificate authority used to verify the receiver | -| `RUSTFS_AUDIT_WEBHOOK_SKIP_TLS_VERIFY_PRIMARY` | Disable server certificate verification | +| `RUSTFS_AUDIT_WEBHOOK_ENDPOINT_PRIMARY` | HTTP- oder HTTPS-Zustellendpunkt | +| `RUSTFS_AUDIT_WEBHOOK_AUTH_TOKEN_PRIMARY` | Bearer-Token, das im Header `Authorization` gesendet wird | +| `RUSTFS_AUDIT_WEBHOOK_QUEUE_DIR_PRIMARY` | Verzeichnis für wartende Audit-Datensätze | +| `RUSTFS_AUDIT_WEBHOOK_QUEUE_LIMIT_PRIMARY` | Maximale Anzahl wartender Datensätze | +| `RUSTFS_AUDIT_WEBHOOK_CLIENT_CERT_PRIMARY` | Client-Zertifikat für gegenseitiges TLS (mTLS) | +| `RUSTFS_AUDIT_WEBHOOK_CLIENT_KEY_PRIMARY` | Privater Schlüssel zum Client-Zertifikat | +| `RUSTFS_AUDIT_WEBHOOK_CLIENT_CA_PRIMARY` | Zertifizierungsstelle, mit der der Empfänger geprüft wird | +| `RUSTFS_AUDIT_WEBHOOK_SKIP_TLS_VERIFY_PRIMARY` | Deaktiviert die Prüfung des Serverzertifikats | -:::warning[Protect audit data] +:::warning[Audit-Daten schützen] -Use HTTPS for remote collectors. Keep certificate verification enabled, store bearer tokens outside source control, and provide both the client certificate and key when using mTLS. Audit payloads may contain security-sensitive request and identity metadata. +Verwenden Sie HTTPS für entfernte Sammelstellen. Lassen Sie die Zertifikatsprüfung aktiviert, speichern Sie Bearer-Token außerhalb der Versionsverwaltung und stellen Sie bei mTLS sowohl das Client-Zertifikat als auch den Schlüssel bereit. Audit-Payloads können sicherheitsrelevante Anfrage- und Identitätsmetadaten enthalten. ::: -For all target families and target-specific keys, see [Environment Variables](/reference/environment-variables#event--audit-targets). +Zu allen Zielfamilien und zielspezifischen Schlüsseln siehe [Umgebungsvariablen](/de/reference/environment-variables#event--audit-targets). -### Multiple targets +### Mehrere Ziele -Add a distinct uppercase suffix to define another instance. For example, use `RUSTFS_AUDIT_WEBHOOK_ENABLE_ARCHIVE` and the corresponding `_ARCHIVE` settings to create an `archive` webhook alongside `primary`. +Fügen Sie ein eigenes Suffix in Großbuchstaben hinzu, um eine weitere Instanz zu definieren. Verwenden Sie zum Beispiel `RUSTFS_AUDIT_WEBHOOK_ENABLE_ARCHIVE` und die zugehörigen Einstellungen mit `_ARCHIVE`, um neben `primary` ein Webhook-Ziel `archive` anzulegen. -RustFS fans each audit record out to all enabled targets. A failure in one target does not prevent delivery attempts to the others. +RustFS verteilt jeden Audit-Datensatz an alle aktivierten Ziele. Ein Fehler in einem Ziel verhindert Zustellversuche an die anderen nicht. -:::note[Environment-managed targets] +:::note[Über Umgebungsvariablen verwaltete Ziele] -A target defined by environment variables cannot be edited or removed through the Console or admin API. Change its environment variables and restart RustFS instead. Do not define the same target through both environment variables and persisted configuration. +Ein Ziel, das durch Umgebungsvariablen definiert ist, lässt sich nicht über die Console oder die Admin-API bearbeiten oder entfernen. Ändern Sie stattdessen seine Umgebungsvariablen und starten Sie RustFS neu. Definieren Sie dasselbe Ziel nicht gleichzeitig über Umgebungsvariablen und über die persistierte Konfiguration. ::: -## Usage +## Verwendung -:::note[rc command-line support] +:::note[Unterstützung in der rc-Befehlszeile] -The current `rc` client does not provide commands for creating, listing, or removing Audit Targets. Configure them through environment variables or the Console. The `rc bucket event` commands manage bucket notification rules only; they do not manage audit delivery. +Der aktuelle `rc`-Client bietet keine Befehle, um Audit-Ziele anzulegen, aufzulisten oder zu entfernen. Konfigurieren Sie sie über Umgebungsvariablen oder die Console. Die Befehle `rc bucket event` verwalten nur Bucket-Benachrichtigungsregeln; sie verwalten nicht die Audit-Zustellung. ::: -### Verify the receiver +### Empfänger prüfen -Before generating traffic, verify that the collector is reachable from the RustFS host and accepts the configured bearer token: +Prüfen Sie, bevor Sie Datenverkehr erzeugen, dass die Sammelstelle vom RustFS-Host erreichbar ist und das konfigurierte Bearer-Token akzeptiert: ```bash curl --fail --head \ https://audit.example.com/ ``` -The health check measures origin reachability and does not include the webhook authorization token. Separately confirm that the configured `/rustfs` delivery path accepts `Authorization: Bearer ` on `POST` requests. +Die Integritätsprüfung misst die Erreichbarkeit des Origins und enthält das Autorisierungstoken des Webhooks nicht. Prüfen Sie getrennt, dass der konfigurierte Zustellpfad `/rustfs` bei `POST`-Anfragen `Authorization: Bearer ` akzeptiert. -If the target remains offline, check DNS, firewall policy, `RUSTFS_OUTBOUND_ALLOW_ORIGINS`, certificate trust, and the origin's response to `HEAD /`. +Wenn das Ziel offline bleibt, prüfen Sie DNS, die Firewall-Richtlinie, `RUSTFS_OUTBOUND_ALLOW_ORIGINS`, das Zertifikatsvertrauen und die Antwort des Origins auf `HEAD /`. -### Generate an audit record +### Audit-Datensatz erzeugen -Perform an authenticated S3 operation against RustFS: +Führen Sie eine authentifizierte S3-Operation gegen RustFS aus: ```bash printf 'hello from RustFS\n' > hello.txt @@ -105,7 +105,7 @@ aws --endpoint-url http://localhost:9000 \ s3 cp hello.txt s3://my-bucket/hello.txt ``` -The webhook receives a JSON audit entry. Fields vary by operation and empty optional fields may be omitted. A representative subset is: +Das Webhook erhält einen JSON-Audit-Eintrag. Die Felder hängen von der Operation ab, und leere optionale Felder können entfallen. Eine repräsentative Teilmenge ist: ```json { @@ -128,16 +128,16 @@ The webhook receives a JSON audit entry. Fields vary by operation and empty opti } ``` -Treat the payload schema as additive. Parse the fields you need and tolerate unknown or absent fields so collectors remain compatible with later RustFS releases. +Behandeln Sie das Payload-Schema als erweiterbar. Werten Sie die Felder aus, die Sie benötigen, und tolerieren Sie unbekannte oder fehlende Felder, damit Sammelstellen mit späteren RustFS-Versionen kompatibel bleiben. -### Delivery behavior +### Zustellverhalten -When `RUSTFS_AUDIT_WEBHOOK_QUEUE_DIR_PRIMARY` is configured, RustFS stores pending records on disk and replays them after transient delivery failures. Size the queue directory and `RUSTFS_AUDIT_WEBHOOK_QUEUE_LIMIT_PRIMARY` for the expected outage window, then monitor both disk usage and target health. +Wenn `RUSTFS_AUDIT_WEBHOOK_QUEUE_DIR_PRIMARY` konfiguriert ist, speichert RustFS ausstehende Datensätze auf der Festplatte und spielt sie nach vorübergehenden Zustellfehlern erneut ab. Dimensionieren Sie das Warteschlangenverzeichnis und `RUSTFS_AUDIT_WEBHOOK_QUEUE_LIMIT_PRIMARY` für das erwartete Ausfallfenster und überwachen Sie anschließend sowohl die Festplattennutzung als auch den Zustand des Ziels. -Webhook delivery is at least once. A timeout can occur after the receiver processes a request but before RustFS observes the response, so use `requestID` and other stable fields to deduplicate records where required. +Die Webhook-Zustellung erfolgt mindestens einmal. Eine Zeitüberschreitung kann eintreten, nachdem der Empfänger eine Anfrage verarbeitet hat, aber bevor RustFS die Antwort sieht. Verwenden Sie deshalb `requestID` und andere stabile Felder, um Datensätze dort zu deduplizieren, wo das erforderlich ist. -The receiver should acknowledge a record only after it has durably accepted it. Returning a non-success status keeps failures visible to the delivery path; silently accepting and discarding a record cannot be recovered by RustFS. +Der Empfänger sollte einen Datensatz erst bestätigen, nachdem er ihn dauerhaft angenommen hat. Ein Status ungleich Erfolg hält Fehler für den Zustellweg sichtbar. Nimmt der Empfänger einen Datensatz stillschweigend an und verwirft ihn, kann RustFS das nicht nachholen. -## Next steps +## Nächste Schritte -Configure [Event Notifications](/operations/event-notifications) for bucket-scoped application workflows. Review [Observability](/operations/observability) to monitor service health and [Credentials](/operations/credentials) to limit administrative access. \ No newline at end of file +Konfigurieren Sie [Ereignisbenachrichtigungen](/de/operations/event-notifications) für anwendungsbezogene Abläufe auf Bucket-Ebene. Lesen Sie [Observability](/de/operations/observability), um den Zustand des Dienstes zu überwachen, und [Anmeldedaten](/de/operations/credentials), um den administrativen Zugriff zu begrenzen. diff --git a/content/de/security-compliance/encryption/index.md b/content/de/security-compliance/encryption/index.md index 0737b6cfa..b8b9df6c4 100644 --- a/content/de/security-compliance/encryption/index.md +++ b/content/de/security-compliance/encryption/index.md @@ -1,14 +1,14 @@ --- -title: "Data Encryption" -description: "Find the verified RustFS server-side encryption and key management references." +title: "Datenverschlüsselung" +description: "Hier finden Sie die geprüften Referenzen zu serverseitiger Verschlüsselung und Schlüsselverwaltung in RustFS." --- -RustFS provides server-side encryption options for data stored in the object storage service. Use this section to choose the key-management model that matches your security requirements. +RustFS bietet Optionen für serverseitige Verschlüsselung von Daten im Objektspeicher. In diesem Abschnitt wählen Sie das Schlüsselverwaltungsmodell, das zu Ihren Sicherheitsanforderungen passt. -## Encryption options +## Verschlüsselungsoptionen -- [SSE-S3](./sse-s.md) covers server-managed server-side encryption with the S3 `AES256` mode. -- [SSE-C](./sse-c.md) covers server-side encryption with customer-provided keys. -- [SSE-KMS](./kms.md) covers Local, Vault KV2, and Vault Transit key-management backends. +- [SSE-S3](./sse-s.md) beschreibt die vom Server verwaltete serverseitige Verschlüsselung im S3-Modus `AES256`. +- [SSE-C](./sse-c.md) beschreibt die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln. +- [SSE-KMS](./kms.md) beschreibt die Schlüsselverwaltungs-Backends Local, Vault KV2 und Vault Transit. -For the currently verified KMS configuration surface, see the [CLI reference](/reference/cli) and [environment variable reference](/reference/environment-variables). \ No newline at end of file +Die derzeit geprüfte KMS-Konfiguration finden Sie in der [CLI-Referenz](/de/reference/cli) und in der [Referenz der Umgebungsvariablen](/de/reference/environment-variables). diff --git a/content/de/security-compliance/encryption/kms.md b/content/de/security-compliance/encryption/kms.md index a1db65686..b1aceffef 100644 --- a/content/de/security-compliance/encryption/kms.md +++ b/content/de/security-compliance/encryption/kms.md @@ -1,44 +1,44 @@ --- title: "SSE-KMS" -description: "Configure SSE-KMS with a local or HashiCorp Vault KMS backend for RustFS." +description: "Konfigurieren Sie SSE-KMS mit einem lokalen oder einem HashiCorp-Vault-KMS-Backend für RustFS." --- -RustFS Key Management Service (KMS) generates and wraps per-object data encryption keys for [SSE-S3](./sse-s.md) and SSE-KMS. This guide configures SSE-KMS at server startup with a local key store, Vault KV v2, or Vault Transit. +Der Key Management Service (KMS) von RustFS erzeugt und umhüllt Datenverschlüsselungsschlüssel je Objekt für [SSE-S3](./sse-s.md) und SSE-KMS. In dieser Anleitung konfigurieren Sie SSE-KMS beim Serverstart mit einem lokalen Schlüsselspeicher, Vault KV v2 oder Vault Transit. -## Requirements +## Anforderungen -- Install and configure [`rc`](/operations/rc) for the encryption verification workflow. -- Back up all existing data and KMS key material before changing encryption configuration. -- Apply the same KMS backend and default key ID to every RustFS node. -- Use a process manager or secret manager that injects secrets without committing them to source control. -- For Vault, enable the required secrets engines, create a least-privilege token, and make Vault reachable from every RustFS node. -- Provision a KMS master key before configuring its ID as the RustFS default key. +- Installieren und konfigurieren Sie [`rc`](/de/operations/rc) für den Ablauf zur Prüfung der Verschlüsselung. +- Sichern Sie alle vorhandenen Daten und das KMS-Schlüsselmaterial, bevor Sie die Verschlüsselungskonfiguration ändern. +- Verwenden Sie auf jedem RustFS-Knoten dasselbe KMS-Backend und dieselbe Standard-Schlüssel-ID. +- Verwenden Sie einen Prozess- oder Secret-Manager, der Geheimnisse einbindet, ohne sie in die Versionsverwaltung zu übernehmen. +- Aktivieren Sie für Vault die erforderlichen Secrets Engines, erstellen Sie ein Token mit geringsten Rechten und stellen Sie sicher, dass Vault von jedem RustFS-Knoten erreichbar ist. +- Legen Sie einen KMS-Hauptschlüssel an, bevor Sie seine ID als Standardschlüssel von RustFS konfigurieren. -:::warning[Key loss makes encrypted objects unreadable] +:::warning[Ohne den Schlüssel sind verschlüsselte Objekte nicht lesbar] -RustFS does not store a recoverable copy of your KMS master key outside the configured backend. Back up local key files and their master key, or protect Vault data and recovery credentials, before writing encrypted objects. +RustFS speichert keine wiederherstellbare Kopie Ihres KMS-Hauptschlüssels außerhalb des konfigurierten Backends. Sichern Sie lokale Schlüsseldateien und ihren Hauptschlüssel oder schützen Sie Vault-Daten und Wiederherstellungs-Anmeldedaten, bevor Sie verschlüsselte Objekte schreiben. ::: -## Choose a backend +## Backend wählen -| Backend | `RUSTFS_KMS_BACKEND` | Key storage and wrapping | Intended use | +| Backend | `RUSTFS_KMS_BACKEND` | Schlüsselspeicherung und Umhüllung | Vorgesehener Einsatz | | --- | --- | --- | --- | -| Local | `local` | Key files on the RustFS host | Development, testing, or a carefully backed-up single-host deployment | -| Vault KV2 | `vault` or `vault-kv2` | Master key material in Vault KV v2; data-key wrapping in RustFS | Centralized key storage | -| Vault Transit | `vault-transit` | Cryptographic operations through Vault Transit | Centralized production key management without the KV2 backend mode | +| Local | `local` | Schlüsseldateien auf dem RustFS-Host | Entwicklung, Tests oder eine sorgfältig gesicherte Bereitstellung auf einem einzelnen Host | +| Vault KV2 | `vault` oder `vault-kv2` | Hauptschlüsselmaterial in Vault KV v2; Umhüllung der Datenschlüssel in RustFS | Zentrale Schlüsselspeicherung | +| Vault Transit | `vault-transit` | Kryptografische Operationen über Vault Transit | Zentrale Schlüsselverwaltung in der Produktion ohne den KV2-Backend-Modus | -SSE-S3 and SSE-KMS both require the KMS service to be running. Configuring a bucket default alone does not make encrypted writes succeed when KMS is unavailable. +SSE-S3 und SSE-KMS setzen voraus, dass der KMS-Dienst läuft. Allein ein Bucket-Standard führt nicht dazu, dass verschlüsselte Schreibvorgänge gelingen, wenn KMS nicht verfügbar ist. -## Configure the local backend +## Lokales Backend konfigurieren -Create an absolute key directory owned by the RustFS service account: +Legen Sie ein absolutes Schlüsselverzeichnis an, das dem Dienstkonto von RustFS gehört: ```bash sudo install -d -m 0700 -o rustfs -g rustfs /var/lib/rustfs/kms ``` -Add the KMS settings to the RustFS environment file on every node: +Fügen Sie die KMS-Einstellungen auf jedem Knoten in die Umgebungsdatei von RustFS ein: ```ini title="/etc/default/rustfs" RUSTFS_KMS_ENABLE=true @@ -47,18 +47,18 @@ RUSTFS_KMS_KEY_DIR=/var/lib/rustfs/kms RUSTFS_KMS_LOCAL_MASTER_KEY= ``` -`RUSTFS_KMS_KEY_DIR` is required by the RustFS server startup path. The local backend writes key files with owner-only permissions. RustFS rejects development defaults such as a temporary key directory or missing local master key unless you explicitly set `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS=true`; never enable that override in production. +`RUSTFS_KMS_KEY_DIR` ist im Startpfad des RustFS-Servers erforderlich. Das lokale Backend schreibt Schlüsseldateien mit Rechten nur für den Eigentümer. RustFS lehnt Entwicklungsstandards wie ein temporäres Schlüsselverzeichnis oder einen fehlenden lokalen Hauptschlüssel ab, es sei denn, Sie setzen ausdrücklich `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS=true`. Aktivieren Sie diese Überschreibung in der Produktion nicht. -Restart RustFS after updating the environment. This starts the KMS backend but does not create a master key: +Starten Sie RustFS nach der Änderung der Umgebung neu. Dadurch startet das KMS-Backend, ein Hauptschlüssel wird jedoch nicht angelegt: ```bash sudo systemctl restart rustfs sudo systemctl status rustfs --no-pager ``` -## Configure Vault KV2 +## Vault KV2 konfigurieren -Enable a KV v2 engine for master key material and metadata. RustFS reads the master key material and wraps data keys locally; this backend does not call Vault Transit. Configure every RustFS node: +Aktivieren Sie eine KV-v2-Engine für Hauptschlüsselmaterial und Metadaten. RustFS liest das Hauptschlüsselmaterial und umhüllt Datenschlüssel lokal; dieses Backend ruft Vault Transit nicht auf. Konfigurieren Sie jeden RustFS-Knoten: ```ini title="/etc/default/rustfs" RUSTFS_KMS_ENABLE=true @@ -69,15 +69,15 @@ RUSTFS_KMS_VAULT_KV_MOUNT=secret RUSTFS_KMS_VAULT_KEY_PREFIX=rustfs/kms/keys ``` -The KV mount defaults to `secret` and the key prefix to `rustfs/kms/keys`; the variables above let you select different paths. Use a Vault token authorized for the configured KV data and metadata paths. `RUSTFS_KMS_VAULT_MOUNT_PATH` is deprecated and unused for the KV2 backend. +Der KV-Mount ist standardmäßig `secret`, das Schlüsselpräfix `rustfs/kms/keys`. Mit den Variablen oben wählen Sie andere Pfade. Verwenden Sie ein Vault-Token, das für die konfigurierten KV-Daten- und Metadatenpfade berechtigt ist. `RUSTFS_KMS_VAULT_MOUNT_PATH` ist veraltet und wird für das KV2-Backend nicht verwendet. -Master key material is Base64-encoded in KV2. Any identity with KV read access to the key path can recover the plaintext master key, so restrict that access to trusted RustFS identities. +Das Hauptschlüsselmaterial liegt in KV2 Base64-kodiert vor. Jede Identität mit KV-Leserecht auf den Schlüsselpfad kann den Hauptschlüssel im Klartext wiederherstellen. Beschränken Sie diesen Zugriff deshalb auf vertrauenswürdige RustFS-Identitäten. -RustFS validates the Vault URL and rejects insecure development defaults unless `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS=true` is set. Use HTTPS and a certificate trusted by the RustFS hosts in production. +RustFS prüft die Vault-URL und lehnt unsichere Entwicklungsstandards ab, sofern `RUSTFS_KMS_ALLOW_INSECURE_DEV_DEFAULTS=true` nicht gesetzt ist. Verwenden Sie in der Produktion HTTPS und ein Zertifikat, dem die RustFS-Hosts vertrauen. -## Configure Vault Transit +## Vault Transit konfigurieren -Enable the Transit engine and configure every RustFS node: +Aktivieren Sie die Transit-Engine und konfigurieren Sie jeden RustFS-Knoten: ```ini title="/etc/default/rustfs" RUSTFS_KMS_ENABLE=true @@ -87,13 +87,13 @@ RUSTFS_KMS_VAULT_TOKEN= RUSTFS_KMS_VAULT_MOUNT_PATH=transit ``` -Vault Transit retains historical key versions, so rotating a Transit key does not by itself make objects wrapped with an older version unreadable. Keep old versions enabled for as long as objects depend on them. +Vault Transit behält historische Schlüsselversionen. Die Rotation eines Transit-Schlüssels allein macht Objekte, die mit einer älteren Version umhüllt wurden, nicht unlesbar. Lassen Sie alte Versionen so lange aktiviert, wie Objekte von ihnen abhängen. -## Create and select the default key +## Standardschlüssel anlegen und auswählen -`RUSTFS_KMS_DEFAULT_KEY_ID` selects an existing key; it does not create one. Start the KMS backend without this variable, create the key, and only then add the variable and restart RustFS. +`RUSTFS_KMS_DEFAULT_KEY_ID` wählt einen vorhandenen Schlüssel aus und legt keinen an. Starten Sie das KMS-Backend ohne diese Variable, legen Sie den Schlüssel an und fügen Sie die Variable erst danach hinzu. Starten Sie RustFS anschließend neu. -When your installed `rc` exposes the KMS lifecycle commands, create and inspect a key with: +Wenn das installierte `rc` die KMS-Lebenszyklusbefehle bereitstellt, legen Sie einen Schlüssel an und rufen Sie seinen Status ab: ```bash rc admin kms status rustfs @@ -101,29 +101,31 @@ rc admin kms key create rustfs --name rustfs-default-key rc admin kms key status rustfs rustfs-default-key ``` -Then add the same default key ID on every RustFS node: +Fügen Sie anschließend auf jedem RustFS-Knoten dieselbe Standard-Schlüssel-ID hinzu: ```ini title="/etc/default/rustfs" RUSTFS_KMS_DEFAULT_KEY_ID=rustfs-default-key ``` -Restart every node consistently after changing the default. +Starten Sie nach der Änderung des Standards jeden Knoten einheitlich neu. -For Vault Transit, you can alternatively create the named Transit key directly in Vault before configuring it as the default: +Bei Vault Transit können Sie den benannten Transit-Schlüssel alternativ direkt in Vault anlegen, bevor Sie ihn als Standard konfigurieren: ```bash vault write -f transit/keys/rustfs-default-key ``` -:::note[rc version boundary] +:::note[Anforderungen an die rc-Version] -The tested `rc 0.1.29` on the validation host does not expose `rc admin kms`; it supports only the bucket and object encryption commands used below. Run `rc admin --help` before following the key lifecycle commands. If the KMS command family is absent, use a newer `rc` release that includes it or provision the key through the native RustFS KMS Admin API. +`rc 0.1.29` enthält `rc admin kms` nicht. Es unterstützt nur die unten verwendeten Befehle zur Bucket- und Objektverschlüsselung. Führen Sie `rc admin --help` aus, bevor Sie den Befehlen für den Schlüssel-Lebenszyklus folgen. Fehlt die KMS-Befehlsfamilie, verwenden Sie eine neuere `rc`-Version, die sie enthält, oder legen Sie den Schlüssel über die native RustFS KMS Admin API an. ::: -## Verify KMS-backed encryption + -Create a test bucket, configure SSE-KMS with the default key, upload an object, and read it back: +## KMS-gestützte Verschlüsselung prüfen + +Legen Sie einen Test-Bucket an, konfigurieren Sie SSE-KMS mit dem Standardschlüssel, laden Sie ein Objekt hoch und lesen Sie es zurück: ```bash rc bucket create rustfs/my-bucket @@ -133,7 +135,7 @@ rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt rc object show rustfs/my-bucket/hello.txt ``` -To select a specific KMS key, set it on the bucket default or the individual write: +Um einen bestimmten KMS-Schlüssel auszuwählen, setzen Sie ihn als Bucket-Standard oder beim einzelnen Schreibvorgang: ```bash rc bucket encryption set rustfs/my-bucket \ @@ -144,17 +146,17 @@ rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt \ --enc-kms rustfs/my-bucket/hello.txt=rustfs-default-key ``` -The selector before `=` must exactly match the destination passed to `rc object copy`. +Die Auswahl vor `=` muss exakt dem Ziel entsprechen, das Sie an `rc object copy` übergeben. -## Rotate and recover keys +## Schlüssel rotieren und wiederherstellen -- **Vault token:** issue a replacement token, update every RustFS node, restart consistently, verify encrypted reads and writes, and then revoke the old token. -- **Vault Transit key:** rotate the Transit key in Vault. New wrapping operations use the new version while Vault retains older versions for decryption. -- **Local or Vault KV2 key material:** back up the current material before rotation and verify that objects written before and after rotation remain readable. -- **Existing objects:** rotating a master key does not rewrite object data. Each object keeps the wrapped data key stored with its encryption metadata. +- **Vault-Token:** Stellen Sie ein Ersatz-Token aus, aktualisieren Sie jeden RustFS-Knoten, starten Sie einheitlich neu, prüfen Sie verschlüsselte Lese- und Schreibvorgänge und widerrufen Sie anschließend das alte Token. +- **Vault-Transit-Schlüssel:** Rotieren Sie den Transit-Schlüssel in Vault. Neue Umhüllungen verwenden die neue Version, während Vault ältere Versionen für die Entschlüsselung behält. +- **Schlüsselmaterial von Local oder Vault KV2:** Sichern Sie das aktuelle Material vor der Rotation und prüfen Sie, dass Objekte, die vor und nach der Rotation geschrieben wurden, lesbar bleiben. +- **Vorhandene Objekte:** Die Rotation eines Hauptschlüssels schreibt Objektdaten nicht neu. Jedes Objekt behält den umhüllten Datenschlüssel in seinen Verschlüsselungsmetadaten. -Do not delete or disable an old master-key version until you have established that no retained object depends on it. +Löschen oder deaktivieren Sie eine alte Hauptschlüsselversion erst, wenn feststeht, dass kein aufbewahrtes Objekt von ihr abhängt. -## Next steps +## Nächste Schritte -Configure [SSE-S3](./sse-s.md), or use [SSE-C](./sse-c.md) when the client must retain control of the encryption key. \ No newline at end of file +Konfigurieren Sie [SSE-S3](./sse-s.md), oder verwenden Sie [SSE-C](./sse-c.md), wenn der Client die Kontrolle über den Verschlüsselungsschlüssel behalten muss. diff --git a/content/de/security-compliance/encryption/sse-c.md b/content/de/security-compliance/encryption/sse-c.md index f397d1b62..c645fd648 100644 --- a/content/de/security-compliance/encryption/sse-c.md +++ b/content/de/security-compliance/encryption/sse-c.md @@ -1,26 +1,26 @@ --- title: "SSE-C" -description: "Use customer-provided AES-256 keys for RustFS object encryption and decryption." +description: "Verwenden Sie vom Kunden bereitgestellte AES-256-Schlüssel für die Ver- und Entschlüsselung von Objekten in RustFS." --- -SSE-C encrypts an object with a 256-bit key supplied by the client on every write and read request. RustFS validates and uses the key for the request but does not persist the plaintext customer key. SSE-C does not use the RustFS KMS backend. +SSE-C verschlüsselt ein Objekt mit einem 256-Bit-Schlüssel, den der Client bei jeder Schreib- und Leseanfrage übergibt. RustFS prüft den Schlüssel und verwendet ihn für die Anfrage, speichert den Kundenschlüssel im Klartext jedoch nicht. SSE-C verwendet das KMS-Backend von RustFS nicht. -## Requirements +## Anforderungen -- Install and configure [`rc`](/operations/rc). -- Install OpenSSL for the key-generation example. -- Use HTTPS so customer keys are encrypted in transit. -- Store the customer key in a secret manager and maintain a mapping between each object and its key. +- Installieren und konfigurieren Sie [`rc`](/de/operations/rc). +- Installieren Sie OpenSSL für das Beispiel zur Schlüsselerzeugung. +- Verwenden Sie HTTPS, damit Kundenschlüssel während der Übertragung verschlüsselt sind. +- Speichern Sie den Kundenschlüssel in einem Secret-Manager und pflegen Sie eine Zuordnung zwischen jedem Objekt und seinem Schlüssel. -:::warning[The same key is required for every read] +:::warning[Für jeden Lesezugriff ist derselbe Schlüssel erforderlich] -If you lose an SSE-C key, RustFS cannot recover it and the object becomes unreadable. Never log, commit, or send the key over an unencrypted connection. +Wenn Sie einen SSE-C-Schlüssel verlieren, kann RustFS ihn nicht wiederherstellen und das Objekt wird unlesbar. Protokollieren Sie den Schlüssel nicht, übernehmen Sie ihn nicht in die Versionsverwaltung und senden Sie ihn nicht über eine unverschlüsselte Verbindung. ::: -## Prepare a customer key +## Kundenschlüssel vorbereiten -Generate 32 random bytes through a hexadecimal intermediate, then derive the Base64 key and its Base64-encoded MD5 checksum: +Erzeugen Sie 32 zufällige Bytes über eine hexadezimale Zwischenform und leiten Sie daraus den Base64-Schlüssel und seine Base64-kodierte MD5-Prüfsumme ab: ```bash SSE_C_KEY_HEX=$(openssl rand -hex 32) @@ -29,11 +29,11 @@ SSE_C_KEY_MD5=$(printf '%s' "$SSE_C_KEY_HEX" | xxd -r -p \ | openssl dgst -md5 -binary | openssl base64 -A) ``` -Move these values into your approved secret-management workflow. Do not print them to the terminal or shell history. +Übernehmen Sie diese Werte in Ihren freigegebenen Ablauf zur Geheimnisverwaltung. Geben Sie sie nicht im Terminal oder in der Shell-Historie aus. -## Upload an encrypted object +## Verschlüsseltes Objekt hochladen -`rc 0.1.29` has no dedicated SSE-C option. Its signed custom-header option can send the three S3 SSE-C headers: +`rc 0.1.29` hat keine eigene SSE-C-Option. Die signierte Option für eigene Header kann die drei S3-SSE-C-Header senden: ```bash rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt \ @@ -42,17 +42,17 @@ rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt \ -H "x-amz-server-side-encryption-customer-key-md5:$SSE_C_KEY_MD5" ``` -The required request headers are: +Die erforderlichen Anfrage-Header sind: -| Header | Value | +| Header | Wert | | --- | --- | | `x-amz-server-side-encryption-customer-algorithm` | `AES256` | -| `x-amz-server-side-encryption-customer-key` | Base64-encoded 32-byte key | -| `x-amz-server-side-encryption-customer-key-md5` | Base64-encoded MD5 digest of the raw key | +| `x-amz-server-side-encryption-customer-key` | Base64-kodierter Schlüssel mit 32 Bytes | +| `x-amz-server-side-encryption-customer-key-md5` | Base64-kodierter MD5-Digest des Rohschlüssels | -## Read the encrypted object +## Verschlüsseltes Objekt lesen -Supply the same three headers on reads and metadata requests: +Übergeben Sie dieselben drei Header bei Lesezugriffen und Metadatenanfragen: ```bash rc object show rustfs/my-bucket/hello.txt \ @@ -61,24 +61,24 @@ rc object show rustfs/my-bucket/hello.txt \ -H "x-amz-server-side-encryption-customer-key-md5:$SSE_C_KEY_MD5" ``` -The same workflow was validated with `rc 0.1.29` against RustFS by uploading an object, reading it with the original key, and comparing the returned bytes with the source. +Derselbe Ablauf wurde mit `rc 0.1.29` gegen RustFS geprüft: Ein Objekt wurde hochgeladen, mit dem ursprünglichen Schlüssel gelesen und die zurückgegebenen Bytes wurden mit der Quelle verglichen. -:::warning[Protect command arguments] +:::warning[Befehlsargumente schützen] -The generic `-H` method places expanded header values in the `rc` process arguments, which may be visible to other processes on the host. For production automation, prefer an S3 SDK that accepts SSE-C key material through protected memory or a credential provider instead of command-line arguments. +Die allgemeine Methode `-H` schreibt expandierte Header-Werte in die Prozessargumente von `rc`. Andere Prozesse auf dem Host können sie dadurch sehen. Bevorzugen Sie für die Automatisierung in der Produktion ein S3-SDK, das SSE-C-Schlüsselmaterial über geschützten Speicher oder einen Anbieter für Zugangsdaten entgegennimmt und nicht über Befehlszeilenargumente. ::: -## Clear shell variables +## Shell-Variablen löschen -After the operation, remove key material from the shell environment: +Entfernen Sie das Schlüsselmaterial nach dem Vorgang aus der Shell-Umgebung: ```bash unset SSE_C_KEY_HEX SSE_C_KEY_B64 SSE_C_KEY_MD5 ``` -Changing a bucket's SSE-S3 or SSE-KMS default does not alter SSE-C objects. SSE-C is selected by the customer-key headers on each individual request and takes precedence for that request. +Eine Änderung des SSE-S3- oder SSE-KMS-Standards eines Buckets ändert SSE-C-Objekte nicht. SSE-C wird durch die Kundenschlüssel-Header der einzelnen Anfrage gewählt und hat für diese Anfrage Vorrang. -## Next steps +## Nächste Schritte -Compare [SSE-S3](./sse-s.md) for server-managed encryption and [KMS](./kms.md) for explicit KMS-backed key management. \ No newline at end of file +Vergleichen Sie [SSE-S3](./sse-s.md) für die vom Server verwaltete Verschlüsselung und [KMS](./kms.md) für die ausdrückliche Schlüsselverwaltung über KMS. diff --git a/content/de/security-compliance/encryption/sse-s.md b/content/de/security-compliance/encryption/sse-s.md index 7a4a9929b..6d003619c 100644 --- a/content/de/security-compliance/encryption/sse-s.md +++ b/content/de/security-compliance/encryption/sse-s.md @@ -1,77 +1,77 @@ --- title: "SSE-S3" -description: "Configure server-managed SSE-S3 encryption for RustFS buckets and object writes." +description: "Konfigurieren Sie die vom Server verwaltete SSE-S3-Verschlüsselung für Buckets und Objektschreibvorgänge in RustFS." --- -SSE-S3 uses the S3 `AES256` encryption mode. RustFS generates a unique data encryption key for each encrypted object and uses the configured KMS service to wrap that key. Clients do not provide or retain the encryption key. +SSE-S3 verwendet den S3-Verschlüsselungsmodus `AES256`. RustFS erzeugt für jedes verschlüsselte Objekt einen eigenen Datenverschlüsselungsschlüssel und umhüllt diesen Schlüssel mit dem konfigurierten KMS-Dienst. Clients stellen den Verschlüsselungsschlüssel weder bereit noch bewahren sie ihn auf. -## Requirements +## Anforderungen -- Configure and start [KMS](./kms.md), create its default key, and verify the key is available before enabling SSE-S3. -- Install and configure [`rc`](/operations/rc). -- Create the target bucket and verify that normal object writes succeed. +- Konfigurieren und starten Sie [KMS](./kms.md), legen Sie den Standardschlüssel an und prüfen Sie, dass der Schlüssel verfügbar ist, bevor Sie SSE-S3 aktivieren. +- Installieren und konfigurieren Sie [`rc`](/de/operations/rc). +- Legen Sie den Ziel-Bucket an und prüfen Sie, dass gewöhnliche Objektschreibvorgänge gelingen. -:::warning[KMS availability is required] +:::warning[KMS muss verfügbar sein] -RustFS accepts an SSE-S3 bucket default even when KMS is unavailable, but encrypted object writes then fail. Verify an encrypted write and read before using the bucket for production data. +RustFS akzeptiert einen SSE-S3-Bucket-Standard auch dann, wenn KMS nicht verfügbar ist. Verschlüsselte Objektschreibvorgänge schlagen dann jedoch fehl. Prüfen Sie einen verschlüsselten Schreib- und Lesevorgang, bevor Sie den Bucket für Produktionsdaten verwenden. ::: -## Set bucket default encryption +## Bucket-Standardverschlüsselung setzen -Apply SSE-S3 to new writes that do not specify an object-level encryption mode: +Wenden Sie SSE-S3 auf neue Schreibvorgänge an, die keinen Verschlüsselungsmodus auf Objektebene angeben: ```bash rc bucket encryption set rustfs/my-bucket --mode sse-s3 rc bucket encryption info rustfs/my-bucket ``` -The reported mode should be `SSE-S3`. +Der gemeldete Modus sollte `SSE-S3` sein. -Upload and read a test object: +Laden Sie ein Testobjekt hoch und lesen Sie es: ```bash rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt rc object show rustfs/my-bucket/hello.txt ``` -## Encrypt one object explicitly +## Ein Objekt ausdrücklich verschlüsseln -Apply SSE-S3 to a single destination without changing the bucket default: +Wenden Sie SSE-S3 auf ein einzelnes Ziel an, ohne den Bucket-Standard zu ändern: ```bash rc object copy /path/to/hello.txt rustfs/my-bucket/hello.txt \ --enc-s3 rustfs/my-bucket/hello.txt ``` -For recursive writes, the encryption selector must exactly match the destination prefix: +Bei rekursiven Schreibvorgängen muss die Verschlüsselungsauswahl exakt dem Zielpräfix entsprechen: ```bash rc object copy ./reports/ rustfs/my-bucket/reports/ --recursive \ --enc-s3 rustfs/my-bucket/reports/ ``` -## Clear the bucket default +## Bucket-Standard entfernen -Remove the default rule: +Entfernen Sie die Standardregel: ```bash rc bucket encryption clear rustfs/my-bucket rc bucket encryption info rustfs/my-bucket ``` -Clearing or changing the bucket default affects only later writes. It does not decrypt or rewrite existing objects. +Das Entfernen oder Ändern des Bucket-Standards betrifft nur spätere Schreibvorgänge. Vorhandene Objekte werden dadurch weder entschlüsselt noch neu geschrieben. -## Request contract +## Anfrage-Header -S3 clients request SSE-S3 with: +S3-Clients fordern SSE-S3 so an: ```http x-amz-server-side-encryption: AES256 ``` -An object-level request overrides the bucket default for that write. If no object-level mode is supplied, RustFS resolves the effective mode from the bucket encryption configuration. +Eine Anfrage auf Objektebene überschreibt den Bucket-Standard für diesen Schreibvorgang. Wird kein Modus auf Objektebene angegeben, ermittelt RustFS den wirksamen Modus aus der Verschlüsselungskonfiguration des Buckets. -## Next steps +## Nächste Schritte -Use [SSE-KMS](./kms.md#verify-kms-backed-encryption) when you need an explicit KMS key ID, or compare [SSE-C](./sse-c.md) for client-held keys. \ No newline at end of file +Verwenden Sie [SSE-KMS](./kms.md#verify-kms-backed-encryption), wenn Sie eine ausdrückliche KMS-Schlüssel-ID benötigen, oder vergleichen Sie [SSE-C](./sse-c.md) für Schlüssel, die der Client behält. diff --git a/content/de/security-compliance/iam/access-token.md b/content/de/security-compliance/iam/access-token.md index f3442e3b1..13dc26858 100644 --- a/content/de/security-compliance/iam/access-token.md +++ b/content/de/security-compliance/iam/access-token.md @@ -1,29 +1,29 @@ --- -title: "RustFS Access Key Management" -description: "Creation, usage, and deletion of RustFS access keys." +title: "Zugriffsschlüssel" +description: "Legen Sie Zugriffsschlüssel in der RustFS Console an und löschen Sie sie." --- -RustFS access keys are the core credentials of the RustFS system, used for identity authentication and operation authorization, and are very useful in API and SDK scenarios. This chapter introduces the creation and deletion of RustFS access keys. +Zugriffsschlüssel sind die Zugangsdaten, mit denen Anwendungen und Tools sich bei RustFS authentifizieren und ihre Anfragen autorisieren. Diese Seite zeigt, wie Sie Zugriffsschlüssel in der Console anlegen und löschen. -Prerequisites: +## Voraussetzungen -- An available RustFS instance. You can refer to the [Installation Guide](../../installation/index.md) for installation. +- Eine laufende RustFS-Instanz. Siehe die [Installationsanleitung](../../installation/index.md). -## Creating Access Keys +## Zugriffsschlüssel anlegen -1. Log in to the RustFS UI console. -2. In the left navigation bar, select **Access Keys**. -3. On the access keys page, in the upper right corner, click **Add Access Key**. -4. Enter the key's **expiration time, name, and description**, then click **Submit**. -5. (Optional but recommended). On the access key page that appears, select **Copy** or **Export** to save the access key for future use. +1. Melden Sie sich bei der RustFS Console an. +2. Wählen Sie in der linken Navigationsleiste **Access Keys** (Zugriffsschlüssel). +3. Klicken Sie auf der Seite der Zugriffsschlüssel oben rechts auf **Add Access Key** (Zugriffsschlüssel hinzufügen). +4. Geben Sie **Expiration** (Ablauf), **Name** und **Description** (Beschreibung) für den Schlüssel ein und wählen Sie **Submit** (Absenden). +5. (Empfohlen) Wählen Sie auf der angezeigten Seite **Copy** (Kopieren) oder **Export** (Exportieren), um den Schlüssel zu speichern. -![access key list page](images/access_token_creation.png) +![Seite mit der Liste der Zugriffsschlüssel](images/access_token_creation.png) -## Deleting Access Keys +## Zugriffsschlüssel löschen -1. Log in to the RustFS UI console. -2. In the left navigation bar, select **Access Keys**. -3. On the access keys page, select the access key you want to delete. -4. Select the **Delete** button on the right side of the access key or **Delete Selected Items** in the upper right corner to delete the access key. +1. Melden Sie sich bei der RustFS Console an. +2. Wählen Sie in der linken Navigationsleiste **Access Keys**. +3. Wählen Sie auf der Seite der Zugriffsschlüssel den Zugriffsschlüssel aus, den Sie löschen möchten. +4. Wählen Sie **Delete** (Löschen) neben dem Zugriffsschlüssel oder **Delete Selected Items** (Ausgewählte Elemente löschen) oben rechts. -![access key deletion](images/access_token_deletion.png) \ No newline at end of file +![Löschen eines Zugriffsschlüssels](images/access_token_deletion.png) diff --git a/content/de/security-compliance/iam/index.md b/content/de/security-compliance/iam/index.md index 2d23161d0..6c05af1d4 100644 --- a/content/de/security-compliance/iam/index.md +++ b/content/de/security-compliance/iam/index.md @@ -1,54 +1,56 @@ --- -title: "RustFS IAM Management" -description: "Overview of RustFS Identity and Access Management (IAM): identity types, policy attachment, and policy evaluation semantics." +title: "Identitäts- und Zugriffsverwaltung" +description: "Überblick über die Identitäts- und Zugriffsverwaltung (IAM) in RustFS: Identitätstypen, Richtlinienzuordnung und Auswertungssemantik." --- -RustFS ships a built-in Identity and Access Management (IAM) system modeled on the AWS IAM policy language. Every request — S3 data access, Console operation, or admin API call — is authenticated against a credential and then authorized against the policies attached to that identity. +RustFS bringt eine eingebaute Identitäts- und Zugriffsverwaltung (IAM) mit, die sich an der Richtliniensprache von AWS IAM orientiert. Jede Anfrage — S3-Datenzugriff, Console-Operation oder Admin-API-Aufruf — wird mit Zugangsdaten authentifiziert und anschließend anhand der Richtlinien autorisiert, die dieser Identität zugeordnet sind. -## Identity Types +## Identitätstypen -RustFS distinguishes the following identity types: +RustFS unterscheidet die folgenden Identitätstypen: -| Identity | Created by | Typical use | +| Identität | Angelegt durch | Typische Verwendung | | --- | --- | --- | -| Root credentials | `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` environment variables at server start | Initial setup and break-glass administration. The root account bypasses IAM identity-policy evaluation (owner semantics). | -| IAM users | Console or admin API (`add-user`) | Long-term named accounts for people or applications. | -| Groups | Console or admin API (`update-group-members`) | Attach one policy set to many users at once. Users inherit the policies of every group they belong to. | -| Service accounts (access keys) | Console or admin API (`add-service-account`) | Derived credentials that belong to a parent user. They inherit the parent's permissions, optionally restricted further by an embedded session policy, and can carry an expiration time. | -| STS temporary credentials | `AssumeRole` / `AssumeRoleWithWebIdentity` STS calls | Short-lived credentials (15 minutes to 12 hours) with an access key, secret key, and session token. | -| External OIDC identities | OpenID Connect providers (Keycloak, Authing, and other standard OIDC IdPs) | Console SSO. ID token claims are mapped to RustFS policy names, and RustFS issues STS credentials. | +| Root-Anmeldedaten | Umgebungsvariablen `RUSTFS_ACCESS_KEY` / `RUSTFS_SECRET_KEY` beim Serverstart | Erstkonfiguration und Administration im Notfall (Break-Glass). Das Root-Konto umgeht die Auswertung der IAM-Identitätsrichtlinien (Eigentümer-Semantik). | +| IAM-Benutzer | Console oder Admin-API (`add-user`) | Langfristige benannte Konten für Personen oder Anwendungen. | +| Gruppen | Console oder Admin-API (`update-group-members`) | Ordnen Sie einen Richtliniensatz vielen Benutzern gleichzeitig zu. Benutzer erben die Richtlinien jeder Gruppe, der sie angehören. | +| Dienstkonten (Zugriffsschlüssel) | Console oder Admin-API (`add-service-account`) | Abgeleitete Zugangsdaten, die einem übergeordneten Benutzer gehören. Sie erben die Berechtigungen des übergeordneten Kontos, optional weiter eingeschränkt durch eine eingebettete Sitzungsrichtlinie, und können eine Ablaufzeit tragen. | +| Temporäre STS-Zugangsdaten | STS-Aufrufe `AssumeRole` / `AssumeRoleWithWebIdentity` | Kurzlebige Zugangsdaten (15 Minuten bis 12 Stunden) mit Zugriffsschlüssel, geheimem Zugriffsschlüssel und Sitzungstoken. | +| Externe OIDC-Identitäten | OpenID-Connect-Anbieter (Keycloak, Authing und andere standardkonforme OIDC-Identitätsanbieter) | SSO für die Console. Claims des ID-Tokens werden auf Namen von RustFS-Richtlinien abgebildet, und RustFS stellt STS-Zugangsdaten aus. | :::warning -Root credentials bypass IAM identity policies, but bucket policies can still deny root S3 requests. Only `GetBucketPolicy`, `PutBucketPolicy`, and `DeleteBucketPolicy` bypass a bucket-policy deny so the owner can recover access. Use root credentials only to bootstrap the deployment, then create IAM users and service accounts for day-to-day work. +Root-Anmeldedaten umgehen IAM-Identitätsrichtlinien, aber Bucket-Richtlinien können S3-Anfragen des Root-Kontos weiterhin ablehnen. Nur `GetBucketPolicy`, `PutBucketPolicy` und `DeleteBucketPolicy` umgehen ein Deny der Bucket-Richtlinie, damit der Eigentümer den Zugriff wiederherstellen kann. Verwenden Sie Root-Anmeldedaten nur, um die Bereitstellung einzurichten, und legen Sie anschließend IAM-Benutzer und Dienstkonten für die tägliche Arbeit an. ::: -## How Policies Attach to Identities +## Wie Richtlinien Identitäten zugeordnet werden -Policies are named JSON documents stored in RustFS. Attachment works as follows: +Richtlinien sind benannte JSON-Dokumente, die in RustFS gespeichert sind. Die Zuordnung funktioniert so: -- **User binding** — one or more policy names are attached to an IAM user (`set-user-or-group-policy`, or the `idp/builtin/policy/attach` endpoint which accepts a list of policies). -- **Group binding** — the same mechanism with `isGroup=true`; every member of the group receives the group's policies in addition to their own. -- **Service accounts** — do not get their own policy bindings. They evaluate under the parent user's combined policies. If the service account was created with an explicit policy document, that session policy is applied as an additional restriction (both must allow). -- **STS sessions** — inherit the parent identity's policies. The `Policy` request parameter of `AssumeRole` can embed an additional session policy that further restricts the temporary credentials. -- **OIDC identities** — the ID token's `groups`/`roles` claim values are matched against RustFS policy names; the matched policies govern the issued STS credentials. +- **Benutzerzuordnung** — einem IAM-Benutzer werden ein oder mehrere Richtliniennamen zugeordnet (`set-user-or-group-policy` oder der Endpunkt `idp/builtin/policy/attach`, der eine Liste von Richtlinien akzeptiert). +- **Gruppenzuordnung** — derselbe Mechanismus mit `isGroup=true`; jedes Mitglied der Gruppe erhält die Richtlinien der Gruppe zusätzlich zu den eigenen. +- **Dienstkonten** — erhalten keine eigenen Richtlinienzuordnungen. Sie werden unter den zusammengefassten Richtlinien des übergeordneten Benutzers ausgewertet. Wurde das Dienstkonto mit einem ausdrücklichen Richtliniendokument angelegt, gilt diese Sitzungsrichtlinie als zusätzliche Einschränkung (beide müssen erlauben). +- **STS-Sitzungen** — erben die Richtlinien der übergeordneten Identität. Der Anfrageparameter `Policy` von `AssumeRole` kann eine zusätzliche Sitzungsrichtlinie einbetten, die die temporären Zugangsdaten weiter einschränkt. +- **OIDC-Identitäten** — die Claim-Werte `groups` und `roles` des ID-Tokens werden mit Namen von RustFS-Richtlinien abgeglichen; die passenden Richtlinien gelten für die ausgestellten STS-Zugangsdaten. -RustFS ships these built-in (canned) policies: `readwrite`, `readonly`, `writeonly`, `diagnostics`, and `consoleAdmin`. See [Users, Groups, and Policies](./policies.md) for their contents and for writing custom policies. +RustFS liefert diese integrierten Richtlinien (Canned Policies): `readwrite`, `readonly`, `writeonly`, `diagnostics` und `consoleAdmin`. Siehe [Benutzer, Gruppen und Richtlinien](./policies.md) zu ihrem Inhalt und zum Schreiben eigener Richtlinien. -## Policy Evaluation Semantics + -When an identity has multiple attached policies, RustFS merges their statements (dropping duplicates) and evaluates the merged document: +## Auswertungssemantik von Richtlinien -1. **Explicit deny wins.** All `Deny` statements are checked first; if any matching `Deny` statement applies to the request, the request is rejected regardless of any `Allow`. -2. **Owner shortcut.** The root account bypasses IAM identity-policy evaluation; the bucket-policy checks and exceptions described above still apply. -3. **Explicit allow required.** Otherwise, at least one `Allow` statement must match the requested action and resource. -4. **Default deny.** If no statement matches, the request is denied. +Wenn einer Identität mehrere Richtlinien zugeordnet sind, führt RustFS ihre Statements zusammen (Duplikate entfallen) und wertet das zusammengeführte Dokument aus: -For service accounts and STS sessions carrying a session policy, the effective permission is the intersection: the parent's policies and the session policy must both allow the request. +1. **Ein ausdrückliches Deny hat Vorrang.** Alle `Deny`-Statements werden zuerst geprüft. Trifft ein passendes `Deny` auf die Anfrage zu, wird sie unabhängig von jedem `Allow` abgelehnt. +2. **Sonderfall Eigentümer.** Das Root-Konto umgeht die Auswertung der IAM-Identitätsrichtlinien; die oben beschriebenen Prüfungen und Ausnahmen der Bucket-Richtlinie gelten weiterhin. +3. **Ausdrückliches Allow erforderlich.** Andernfalls muss mindestens ein `Allow`-Statement zur angeforderten Aktion und Ressource passen. +4. **Standard-Deny.** Wenn kein Statement passt, wird die Anfrage abgelehnt. -## In This Section +Bei Dienstkonten und STS-Sitzungen mit einer Sitzungsrichtlinie ist die wirksame Berechtigung die Schnittmenge: Die Richtlinien des übergeordneten Kontos und die Sitzungsrichtlinie müssen die Anfrage beide erlauben. -- [Users, Groups, and Policies](./policies.md) — managing users and groups, the policy document format, and built-in policies. -- [Service Accounts and STS](./sts.md) — derived access keys and temporary credentials via `AssumeRole`. -- [Access Keys](./access-token.md) — creating and deleting access keys from the Console. +## In diesem Abschnitt + +- [Benutzer, Gruppen und Richtlinien](./policies.md) — Benutzer und Gruppen verwalten, das Format des Richtliniendokuments und integrierte Richtlinien. +- [Dienstkonten und STS](./sts.md) — abgeleitete Zugriffsschlüssel und temporäre Zugangsdaten über `AssumeRole`. +- [Zugriffsschlüssel](./access-token.md) — Zugriffsschlüssel in der Console anlegen und löschen. diff --git a/content/de/security-compliance/iam/sts.md b/content/de/security-compliance/iam/sts.md index 8ba58d53b..f4ef4f740 100644 --- a/content/de/security-compliance/iam/sts.md +++ b/content/de/security-compliance/iam/sts.md @@ -1,34 +1,34 @@ --- -title: "Service Accounts and STS" -description: "RustFS service accounts (derived access keys) and temporary credentials via the STS AssumeRole API." +title: "Dienstkonten und STS" +description: "Dienstkonten in RustFS (abgeleitete Zugriffsschlüssel) und temporäre Zugangsdaten über die STS-API AssumeRole." --- -RustFS provides two mechanisms for issuing credentials that are derived from an existing identity: **service accounts** (long-lived access keys owned by a parent user) and **STS temporary credentials** (short-lived keys with a session token). +RustFS bietet zwei Mechanismen, um Zugangsdaten auszustellen, die von einer vorhandenen Identität abgeleitet sind: **Dienstkonten** (langlebige Zugriffsschlüssel eines übergeordneten Benutzers) und **temporäre STS-Zugangsdaten** (kurzlebige Schlüssel mit einem Sitzungstoken). -## Service Accounts +## Dienstkonten -A service account is an access key/secret key pair that belongs to a parent IAM user (or to the root account). It authenticates like a normal key but is authorized as its parent: +Ein Dienstkonto ist ein Paar aus Zugriffsschlüssel und geheimem Zugriffsschlüssel, das einem übergeordneten IAM-Benutzer gehört (oder dem Root-Konto). Es authentifiziert sich wie ein normaler Schlüssel, wird aber als sein übergeordnetes Konto autorisiert: -- **Inherited policy (default).** If the service account is created without a policy, it inherits whatever the parent user's combined policies allow at request time. -- **Session-bound policy.** If a policy document is supplied at creation, it is embedded into the service account. Requests must then be allowed by *both* the parent's policies and the embedded policy. -- **Expiration.** An optional expiration timestamp (RFC 3339) can be set; the credential stops working after that time. +- **Geerbte Richtlinie (Standard).** Wird das Dienstkonto ohne Richtlinie angelegt, erbt es das, was die zusammengefassten Richtlinien des übergeordneten Benutzers zum Zeitpunkt der Anfrage erlauben. +- **An die Sitzung gebundene Richtlinie.** Wird beim Anlegen ein Richtliniendokument übergeben, wird es in das Dienstkonto eingebettet. Anfragen müssen dann sowohl von den Richtlinien des übergeordneten Kontos als auch von der eingebetteten Richtlinie erlaubt sein. +- **Ablauf.** Optional lässt sich ein Ablaufzeitpunkt (RFC 3339) setzen; die Zugangsdaten funktionieren nach diesem Zeitpunkt nicht mehr. -Service accounts cannot call `AssumeRole`, and a service account access key cannot be turned into a regular IAM user. +Dienstkonten können `AssumeRole` nicht aufrufen, und ein Zugriffsschlüssel eines Dienstkontos lässt sich nicht in einen regulären IAM-Benutzer umwandeln. -In the Console, service accounts are managed on the **Access Keys** page — see [Access Key Management](./access-token.md). The admin API exposes: +In der Console verwalten Sie Dienstkonten auf der Seite **Access Keys** (Zugriffsschlüssel); siehe [Zugriffsschlüssel-Verwaltung](./access-token.md). Die Admin-API stellt bereit: -| Operation | Method and path | Notes | +| Operation | Methode und Pfad | Hinweise | | --- | --- | --- | -| Create service account | `PUT /rustfs/admin/v3/add-service-account` | Body below. Also served at `/add-service-accounts`. Requires `admin:CreateServiceAccount` when creating for another user (`targetUser`). | -| List service accounts | `GET /rustfs/admin/v3/list-service-accounts?user=` | Requires `admin:ListServiceAccounts` to list another user's accounts. | -| List access keys (bulk) | `GET /rustfs/admin/v3/list-access-keys-bulk` | Supports filtering to users only, service accounts only, or STS keys only. | -| Service account details | `GET /rustfs/admin/v3/info-service-account?accessKey=` | Returns name, description, parent, expiration, and the session policy (or `impliedPolicy: true` when inherited). | -| Temporary account details | `GET /rustfs/admin/v3/temporary-account-info?accessKey=` | For STS-issued keys. | -| Access key details | `GET /rustfs/admin/v3/info-access-key?accessKey=` | Unified lookup across users, service accounts, and STS keys. | -| Update service account | `POST /rustfs/admin/v3/update-service-account?accessKey=` | Can rotate the secret, change status, name, description, expiration, or replace the policy. | -| Delete service account | `DELETE /rustfs/admin/v3/delete-service-account?accessKey=` | Also served at `/delete-service-accounts`. Non-admin callers can delete only their own service accounts. | +| Dienstkonto anlegen | `PUT /rustfs/admin/v3/add-service-account` | JSON-Body siehe unten. Wird auch unter `/add-service-accounts` bereitgestellt. Erfordert `admin:CreateServiceAccount`, wenn das Konto für einen anderen Benutzer (`targetUser`) angelegt wird. | +| Dienstkonten auflisten | `GET /rustfs/admin/v3/list-service-accounts?user=` | Erfordert `admin:ListServiceAccounts`, um die Konten eines anderen Benutzers aufzulisten. | +| Zugriffsschlüssel gesammelt auflisten | `GET /rustfs/admin/v3/list-access-keys-bulk` | Unterstützt die Filterung auf nur Benutzer, nur Dienstkonten oder nur STS-Schlüssel. | +| Details eines Dienstkontos | `GET /rustfs/admin/v3/info-service-account?accessKey=` | Liefert Name, Beschreibung, übergeordnetes Konto, Ablauf und die Sitzungsrichtlinie (oder `impliedPolicy: true`, wenn sie geerbt wird). | +| Details eines temporären Kontos | `GET /rustfs/admin/v3/temporary-account-info?accessKey=` | Für von STS ausgestellte Schlüssel. | +| Details eines Zugriffsschlüssels | `GET /rustfs/admin/v3/info-access-key?accessKey=` | Einheitliche Abfrage über Benutzer, Dienstkonten und STS-Schlüssel. | +| Dienstkonto aktualisieren | `POST /rustfs/admin/v3/update-service-account?accessKey=` | Kann den geheimen Zugriffsschlüssel rotieren sowie Status, Name, Beschreibung und Ablauf ändern oder die Richtlinie ersetzen. | +| Dienstkonto löschen | `DELETE /rustfs/admin/v3/delete-service-account?accessKey=` | Wird auch unter `/delete-service-accounts` bereitgestellt. Aufrufer ohne Admin-Rechte können nur ihre eigenen Dienstkonten löschen. | -Creation body (all fields optional unless noted): +JSON-Body beim Anlegen (alle Felder optional, sofern nicht anders angegeben): ```json { @@ -44,32 +44,32 @@ Creation body (all fields optional unless noted): :::note -Omit `accessKey`/`secretKey` to have RustFS generate a random pair. Omit `policy` to create an inherited-policy service account. `targetUser` requires admin privileges; regular users create service accounts for themselves. +Lassen Sie `accessKey` und `secretKey` weg, damit RustFS ein zufälliges Paar erzeugt. Lassen Sie `policy` weg, um ein Dienstkonto mit geerbter Richtlinie anzulegen. `targetUser` erfordert Admin-Rechte; reguläre Benutzer legen Dienstkonten für sich selbst an. ::: -## STS Temporary Credentials +## Temporäre STS-Zugangsdaten -RustFS implements an AWS-compatible STS endpoint at the server root (`POST /` with form-encoded parameters). Two actions are supported: +RustFS stellt einen AWS-kompatiblen STS-Endpunkt an der Serverwurzel bereit (`POST /` mit formularcodierten Parametern). Zwei Aktionen werden unterstützt: -- `AssumeRole` — for existing IAM identities, signed with SigV4. -- `AssumeRoleWithWebIdentity` — for OIDC identities, authenticated by the JWT itself (see [External Identity (OIDC)](../oidc/index.md)). +- `AssumeRole` — für vorhandene IAM-Identitäten, signiert mit SigV4. +- `AssumeRoleWithWebIdentity` — für OIDC-Identitäten, authentifiziert durch das JWT selbst (siehe [Externe Identität (OIDC)](../oidc/index.md)). ### AssumeRole -The request must be signed (AWS Signature V4) by a long-term IAM credential — temporary credentials and service accounts cannot call `AssumeRole`. With built-in IAM authorization, RustFS evaluates `sts:AssumeRole` for regular IAM users in deny-only mode: a matching explicit `Deny` rejects the request, but a separate `Allow` is not required. The user must have at least one applicable user or group policy binding, and all bound policy names must resolve. +Die Anfrage muss mit AWS Signature V4 von langfristigen IAM-Zugangsdaten signiert sein. Temporäre Zugangsdaten und Dienstkonten können `AssumeRole` nicht aufrufen. Bei der eingebauten IAM-Autorisierung wertet RustFS `sts:AssumeRole` für reguläre IAM-Benutzer im Nur-Deny-Modus aus: Ein passendes ausdrückliches `Deny` lehnt die Anfrage ab, ein separates `Allow` ist nicht erforderlich. Der Benutzer muss mindestens eine anwendbare Benutzer- oder Gruppenrichtlinienzuordnung haben, und alle zugeordneten Richtliniennamen müssen auflösbar sein. -Form parameters: +Formularparameter: -| Parameter | Required | Description | +| Parameter | Erforderlich | Beschreibung | | --- | --- | --- | -| `Action` | Yes | `AssumeRole`. | -| `Version` | Yes | Must be `2011-06-15`. | -| `DurationSeconds` | No | Credential lifetime in seconds. Default 3600 (1 hour); values are clamped to the range 900 (15 minutes) to 43200 (12 hours). | -| `Policy` | No | An inline session policy (JSON) that further restricts the temporary credentials. | -| `RoleArn`, `RoleSessionName`, `ExternalId` | No | Accepted for AWS compatibility. | +| `Action` | Ja | `AssumeRole`. | +| `Version` | Ja | Muss `2011-06-15` sein. | +| `DurationSeconds` | Nein | Lebensdauer der Zugangsdaten in Sekunden. Standard 3600 (1 Stunde); Werte werden auf den Bereich 900 (15 Minuten) bis 43200 (12 Stunden) begrenzt. | +| `Policy` | Nein | Eine eingebettete Sitzungsrichtlinie (JSON), die die temporären Zugangsdaten weiter einschränkt. | +| `RoleArn`, `RoleSessionName`, `ExternalId` | Nein | Werden aus Kompatibilitätsgründen mit AWS akzeptiert. | -Example: +Beispiel: ```bash curl -s -X POST "https://rustfs.example.com/" \ @@ -80,26 +80,26 @@ curl -s -X POST "https://rustfs.example.com/" \ -d "DurationSeconds=3600" ``` -The response is an XML `AssumeRoleResponse` containing `AccessKeyId`, `SecretAccessKey`, `SessionToken`, and `Expiration`. Use all three values on subsequent S3 requests (the session token goes in `X-Amz-Security-Token`). +Die Antwort ist ein XML-Dokument `AssumeRoleResponse` mit `AccessKeyId`, `SecretAccessKey`, `SessionToken` und `Expiration`. Verwenden Sie alle drei Werte bei nachfolgenden S3-Anfragen (das Sitzungstoken steht in `X-Amz-Security-Token`). -The temporary credential inherits the caller's policies; the `parent` of the credential is the calling access key. If a `Policy` parameter was supplied, it is stored in the session and applied as an additional restriction. +Die temporären Zugangsdaten erben die Richtlinien des Aufrufers; das Feld `parent` der Zugangsdaten ist der aufrufende Zugriffsschlüssel. Wurde ein Parameter `Policy` übergeben, wird er in der Sitzung gespeichert und als zusätzliche Einschränkung angewendet. ### AssumeRoleWithWebIdentity -Used by the OIDC flow; no SigV4 signature is needed because the identity provider's JWT is the authentication: +Wird vom OIDC-Ablauf verwendet. Eine SigV4-Signatur ist nicht erforderlich, weil das JWT des Identitätsanbieters die Authentifizierung ist: -| Parameter | Required | Description | +| Parameter | Erforderlich | Beschreibung | | --- | --- | --- | -| `Action` | Yes | `AssumeRoleWithWebIdentity`. | -| `Version` | Yes | Must be `2011-06-15`. | -| `WebIdentityToken` | Yes | The OIDC ID token issued by a configured provider. | -| `DurationSeconds` | No | Same default and 900–43200 clamping as `AssumeRole`. | -| `Policy` | No | Optional inline session policy. | +| `Action` | Ja | `AssumeRoleWithWebIdentity`. | +| `Version` | Ja | Muss `2011-06-15` sein. | +| `WebIdentityToken` | Ja | Das OIDC-ID-Token, das ein konfigurierter Anbieter ausgestellt hat. | +| `DurationSeconds` | Nein | Derselbe Standard und dieselbe Begrenzung auf 900–43200 wie bei `AssumeRole`. | +| `Policy` | Nein | Optionale eingebettete Sitzungsrichtlinie. | -RustFS verifies the token against the configured provider (signature, issuer, audience, expiry), maps its `groups`/`roles` claims to RustFS policy names, and rejects the request if no policies or groups can be mapped. The response is an XML `AssumeRoleWithWebIdentityResponse` with the same credential fields plus `SubjectFromWebIdentityToken`. +RustFS prüft das Token gegen den konfigurierten Anbieter (Signatur, Aussteller, Zielgruppe, Ablauf), ordnet die Claims `groups` und `roles` Namen von RustFS-Richtlinien zu und lehnt die Anfrage ab, wenn keine Richtlinien oder Gruppen zugeordnet werden können. Die Antwort ist ein XML-Dokument `AssumeRoleWithWebIdentityResponse` mit denselben Zugangsdatenfeldern plus `SubjectFromWebIdentityToken`. :::warning -Keep `DurationSeconds` as short as your workload allows; a leaked temporary credential remains valid until its expiration. +Halten Sie `DurationSeconds` so kurz, wie es Ihre Arbeitslast zulässt. Abgeflossene temporäre Zugangsdaten bleiben bis zu ihrem Ablauf gültig. ::: diff --git a/content/de/security-compliance/index.md b/content/de/security-compliance/index.md index 68960b85d..4647aaa25 100644 --- a/content/de/security-compliance/index.md +++ b/content/de/security-compliance/index.md @@ -1,15 +1,15 @@ --- -title: "Security & Compliance" -description: "Configure identity, encryption, transport security, audit logging, and credentials for RustFS." +title: "Sicherheit und Compliance" +description: "Konfigurieren Sie Identität, Verschlüsselung, Transportsicherheit, Audit-Protokollierung und Anmeldedaten für RustFS." --- -Use this section to secure access to RustFS and configure the controls required by your environment. +In diesem Abschnitt sichern Sie den Zugriff auf RustFS und richten die Kontrollen ein, die Ihre Umgebung verlangt. -## Security areas +## Sicherheitsbereiche -- [IAM Management](./iam/index.md) covers users, groups, policies, and access keys. -- [Data Encryption](./encryption/index.md) covers server-side encryption options and key management. -- [OIDC](./oidc/index.md) covers external identity providers. -- [TLS Configuration](/integration/tls-configured) covers encrypted client and node connections. -- [Audit Logs](./audit-logs.md) covers audit target configuration. -- [Credential Management](/operations/credentials) covers root credentials and secret injection. +- [IAM-Verwaltung](./iam/index.md) beschreibt Benutzer, Gruppen, Richtlinien und Zugriffsschlüssel. +- [Datenverschlüsselung](./encryption/index.md) beschreibt Optionen für serverseitige Verschlüsselung und die Schlüsselverwaltung. +- [OIDC](./oidc/index.md) beschreibt externe Identitätsanbieter. +- [TLS-Konfiguration](/de/integration/tls-configured) beschreibt verschlüsselte Verbindungen von Clients und Knoten. +- [Audit-Protokolle](./audit-logs.md) beschreiben die Konfiguration von Audit-Zielen. +- [Anmeldedatenverwaltung](/de/operations/credentials) beschreibt Root-Anmeldedaten und das Einbinden von Geheimnissen. diff --git a/content/de/security-compliance/meta.json b/content/de/security-compliance/meta.json index b7969a612..a18464136 100644 --- a/content/de/security-compliance/meta.json +++ b/content/de/security-compliance/meta.json @@ -8,6 +8,6 @@ "oidc", "[TLS-Konfiguration](/de/integration/tls-configured)", "audit-logs", - "[Zugangsdatenverwaltung](/de/operations/credentials)" + "[Anmeldedatenverwaltung](/de/operations/credentials)" ] } diff --git a/content/de/security-compliance/oidc/gitlab.md b/content/de/security-compliance/oidc/gitlab.md index 2c8ead1fc..477e3a5bf 100644 --- a/content/de/security-compliance/oidc/gitlab.md +++ b/content/de/security-compliance/oidc/gitlab.md @@ -1,76 +1,76 @@ --- title: "GitLab" -description: "Configure GitLab as an OpenID Connect identity provider for RustFS Console single sign-on." +description: "Konfigurieren Sie GitLab als OpenID-Connect-Identitätsanbieter für das Single Sign-On der RustFS Console." --- -RustFS integrates with **GitLab** through the OpenID Connect (OIDC) Authorization Code Flow. The examples on this page use the default RustFS provider ID, `default`. +RustFS lässt sich über den OpenID-Connect-Ablauf Authorization Code Flow (OIDC) mit **GitLab** verbinden. Die Beispiele auf dieser Seite verwenden die standardmäßige RustFS-Provider-ID `default`. -## Requirements +## Anforderungen -Before you begin, prepare: +Bereiten Sie vor dem Beginn Folgendes vor: -- An [installed GitLab instance](https://about.gitlab.com/install/) and access to its Admin area. -- A RustFS deployment with a public HTTPS Console origin. -- A RustFS policy to assign to GitLab users. The examples use `consoleAdmin`; use a policy with only the permissions your users require in production. +- Eine [installierte GitLab-Instanz](https://about.gitlab.com/install/) und Zugriff auf ihren Administrationsbereich. +- Eine RustFS-Bereitstellung mit einem öffentlichen HTTPS-Origin der Console. +- Eine RustFS-Richtlinie, die Sie GitLab-Benutzern zuweisen. Die Beispiele verwenden `consoleAdmin`. Verwenden Sie in der Produktion eine Richtlinie, die nur die Berechtigungen enthält, die Ihre Benutzer benötigen. -## Overview +## Überblick -The browser login flow is: +Der Anmeldeablauf im Browser ist: -1. RustFS sends an authorization-code request with a Proof Key for Code Exchange (PKCE) S256 challenge. -2. GitLab authenticates the user and redirects the browser to RustFS with `code` and `state`. -3. RustFS exchanges the code at the GitLab token endpoint. -4. RustFS verifies the ID token signature, issuer, audience, expiry, and nonce. -5. RustFS assigns the configured local Identity and Access Management (IAM) policy and issues temporary credentials for the Console session. +1. RustFS sendet eine Authorization-Code-Anfrage mit einer S256-Challenge nach Proof Key for Code Exchange (PKCE). +2. GitLab authentifiziert den Benutzer und leitet den Browser mit `code` und `state` zu RustFS zurück. +3. RustFS tauscht den Code am Token-Endpunkt von GitLab ein. +4. RustFS prüft Signatur, Aussteller, Zielgruppe, Ablauf und Nonce des ID-Tokens. +5. RustFS weist die konfigurierte lokale Richtlinie der Identitäts- und Zugriffsverwaltung (IAM) zu und stellt temporäre Zugangsdaten für die Console-Sitzung aus. -GitLab authenticates the user, while RustFS policies authorize S3 and administration operations. +GitLab authentifiziert den Benutzer; die RustFS-Richtlinien autorisieren S3- und Verwaltungsoperationen. -The examples use the following values. Replace the hostnames and client secret for your environment: +Die Beispiele verwenden die folgenden Werte. Ersetzen Sie Hostnamen und Client-Secret für Ihre Umgebung: -| Setting | Example | +| Einstellung | Beispiel | | --- | --- | -| GitLab issuer | `https://gitlab.example.com` | -| GitLab application ID | `` | -| Public RustFS origin | `https://rustfs.example.com` | -| RustFS callback URL | `https://rustfs.example.com/rustfs/admin/v3/oidc/callback/default` | +| GitLab-Issuer | `https://gitlab.example.com` | +| GitLab-Anwendungs-ID | `` | +| Öffentlicher RustFS-Origin | `https://rustfs.example.com` | +| RustFS-Callback-URL | `https://rustfs.example.com/rustfs/admin/v3/oidc/callback/default` | -## Configuration +## Konfiguration -### GitLab configuration +### GitLab konfigurieren -#### Create the OAuth application +#### OAuth-Anwendung anlegen -1. Sign in to GitLab as an administrator. -2. Open **Admin Area**, select **Applications**, and select **New application**. -3. Enter `RustFS OIDC` as the application name. -4. Set **Redirect URI** to the exact RustFS callback URL: +1. Melden Sie sich bei GitLab als Administrator an. +2. Öffnen Sie **Admin Area** (Administrationsbereich), wählen Sie **Applications** (Anwendungen) und wählen Sie **New application** (Neue Anwendung). +3. Geben Sie `RustFS OIDC` als Anwendungsnamen ein. +4. Setzen Sie **Redirect URI** (Umleitungs-URI) auf die genaue RustFS-Callback-URL: ```text https://rustfs.example.com/rustfs/admin/v3/oidc/callback/default ``` -5. Enable **Confidential**. -6. Enable **Trusted** to skip the user authorization prompt for this instance-wide application. -7. Select the `openid`, `profile`, and `email` scopes. -8. Save the application, then copy the generated application ID and secret. +5. Aktivieren Sie **Confidential** (Vertraulich). +6. Aktivieren Sie **Trusted** (Vertrauenswürdig), um die Benutzerabfrage zur Autorisierung für diese instanzweite Anwendung zu überspringen. +7. Wählen Sie die Scopes `openid`, `profile` und `email`. +8. Speichern Sie die Anwendung und kopieren Sie die erzeugte Anwendungs-ID und das Secret. -See the [GitLab OAuth provider documentation](https://docs.gitlab.com/integration/oauth_provider/) for details about administering applications. +Einzelheiten zur Verwaltung von Anwendungen finden Sie in der [GitLab-Dokumentation zum OAuth-Provider](https://docs.gitlab.com/integration/oauth_provider/). -![GitLab Admin area showing the RustFS OIDC instance OAuth application as trusted and confidential](./images/gitlab-oidc-configuration.png) +![GitLab-Administrationsbereich mit der vertrauenswürdigen und vertraulichen Instanz-OAuth-Anwendung RustFS OIDC](./images/gitlab-oidc-configuration.png) -:::note[Test environment shown] +:::note[Gezeigte Testumgebung] -The screenshot shows an HTTP callback URL from a test environment. Use the public HTTPS callback URL for your RustFS deployment. +Der Screenshot zeigt eine HTTP-Callback-URL aus einer Testumgebung. Verwenden Sie für Ihre RustFS-Bereitstellung die öffentliche HTTPS-Callback-URL. ::: -### RustFS configuration +### RustFS konfigurieren -Configure the GitLab provider through environment variables. +Konfigurieren Sie den GitLab-Anbieter über Umgebungsvariablen. -#### Configure with environment variables +#### Mit Umgebungsvariablen konfigurieren -Add the GitLab provider and public browser origin to the RustFS service environment: +Fügen Sie den GitLab-Anbieter und den öffentlichen Browser-Origin zur Dienstumgebung von RustFS hinzu: ```ini title="/etc/default/rustfs" RUSTFS_BROWSER_REDIRECT_URL="https://rustfs.example.com" @@ -88,23 +88,23 @@ RUSTFS_IDENTITY_OPENID_USERNAME_CLAIM="preferred_username" RUSTFS_IDENTITY_OPENID_ROLE_POLICY="consoleAdmin" ``` -Restart RustFS after applying the configuration. +Starten Sie RustFS neu, nachdem Sie die Konfiguration angewendet haben. -`RUSTFS_BROWSER_REDIRECT_URL` must contain the public scheme and authority without a path. It controls the Console success redirect and logout fallback URL. The provider callback URL must exactly match the URL registered in GitLab. +`RUSTFS_BROWSER_REDIRECT_URL` muss das öffentliche Schema und die Authority (Host, optional mit Port) ohne Pfad enthalten. Die Variable steuert die Erfolgsweiterleitung der Console und die Ersatz-URL beim Abmelden. Die Callback-URL des Anbieters muss exakt der in GitLab registrierten URL entsprechen. -:::warning[Limit the assigned policy] +:::warning[Zugewiesene Richtlinie begrenzen] -`RUSTFS_IDENTITY_OPENID_ROLE_POLICY` assigns the same RustFS policy to every user who signs in through this provider. Replace `consoleAdmin` with a policy that grants only the permissions required by your GitLab users. +`RUSTFS_IDENTITY_OPENID_ROLE_POLICY` weist jedem Benutzer, der sich über diesen Anbieter anmeldet, dieselbe RustFS-Richtlinie zu. Ersetzen Sie `consoleAdmin` durch eine Richtlinie, die nur die Berechtigungen gewährt, die Ihre GitLab-Benutzer benötigen. ::: -For a reverse proxy or load balancer, preserve the callback query string and route the authorize and callback requests to the same RustFS node. The in-flight OIDC `state` is local to that node. +Bewahren Sie bei einem Reverse-Proxy oder Load Balancer die Abfragezeichenfolge des Callbacks auf und leiten Sie Autorisierungs- und Callback-Anfragen an denselben RustFS-Knoten. Der laufende OIDC-`state` gilt nur auf diesem Knoten. -## Verification +## Überprüfung -### Verify GitLab discovery +### GitLab-Discovery prüfen -Query the GitLab discovery document: +Fragen Sie das Discovery-Dokument von GitLab ab: ```bash curl -fsS "https://gitlab.example.com/.well-known/openid-configuration" | jq '{ @@ -117,44 +117,44 @@ curl -fsS "https://gitlab.example.com/.well-known/openid-configuration" | jq '{ }' ``` -Confirm that: +Prüfen Sie Folgendes: -- `issuer` is `https://gitlab.example.com`. -- `authorization_endpoint`, `token_endpoint`, and `jwks_uri` are present. -- `scopes_supported` includes `openid`, `profile`, and `email`. -- `code_challenge_methods_supported` includes `S256`. +- `issuer` den Wert `https://gitlab.example.com` hat. +- `authorization_endpoint`, `token_endpoint` und `jwks_uri` vorhanden sind. +- `scopes_supported` die Werte `openid`, `profile` und `email` enthält. +- `code_challenge_methods_supported` den Wert `S256` enthält. -### Verify the RustFS provider +### RustFS-Provider prüfen -After restarting RustFS, check that the provider is available: +Prüfen Sie nach dem Neustart von RustFS, ob der Anbieter verfügbar ist: ```bash curl -fsS "https://rustfs.example.com/rustfs/admin/v3/oidc/providers" | jq ``` -The response should include the `default` provider with the display name `GitLab`. +Die Antwort sollte den Anbieter `default` mit dem Anzeigenamen `GitLab` enthalten. -### Test Console login +### Console-Anmeldung testen -Open the RustFS Console and select **GitLab**, or open the authorization endpoint directly: +Öffnen Sie die RustFS Console und wählen Sie **GitLab**, oder öffnen Sie den Autorisierungsendpunkt direkt: ```text https://rustfs.example.com/rustfs/admin/v3/oidc/authorize/default ``` -![RustFS Console login page showing the Login with GitLab option](./images/rustfs-console-gitlab-oidc.png) +![Anmeldeseite der RustFS Console mit der Option Login with GitLab](./images/rustfs-console-gitlab-oidc.png) -Verify the complete flow: +Prüfen Sie den vollständigen Ablauf: -1. The browser redirects to GitLab. -2. The user signs in and authorizes the application when prompted. -3. GitLab redirects to the RustFS callback URL with `code` and `state`. -4. RustFS validates the ID token and creates the Console session. -5. The Console opens with the configured RustFS policy. +1. Der Browser wird zu GitLab weitergeleitet. +2. Der Benutzer meldet sich an und autorisiert die Anwendung, wenn er dazu aufgefordert wird. +3. GitLab leitet zur RustFS-Callback-URL weiter und übergibt `code` und `state`. +4. RustFS prüft das ID-Token und legt die Console-Sitzung an. +5. Die Console öffnet sich mit der konfigurierten RustFS-Richtlinie. -If GitLab reports a redirect URI mismatch, confirm that the URI registered in the GitLab application exactly matches `RUSTFS_IDENTITY_OPENID_REDIRECT_URI`. +Wenn GitLab eine abweichende Redirect-URI meldet, prüfen Sie, dass die in der GitLab-Anwendung registrierte URI exakt `RUSTFS_IDENTITY_OPENID_REDIRECT_URI` entspricht. -## Next steps +## Nächste Schritte -- Review [users, groups, and policies](../iam/policies.md) before selecting the policy assigned to GitLab users. -- Review the [Console security notes](/administration/console) before exposing the login endpoint publicly. \ No newline at end of file +- Lesen Sie [Benutzer, Gruppen und Richtlinien](../iam/policies.md), bevor Sie die Richtlinie auswählen, die GitLab-Benutzern zugewiesen wird. +- Lesen Sie die [Sicherheitshinweise zur Console](/de/administration/console), bevor Sie den Anmeldeendpunkt öffentlich bereitstellen. diff --git a/content/de/security-compliance/oidc/index.md b/content/de/security-compliance/oidc/index.md index 0d784b7ad..b225d8856 100644 --- a/content/de/security-compliance/oidc/index.md +++ b/content/de/security-compliance/oidc/index.md @@ -1,40 +1,40 @@ --- title: "OIDC" -description: "Understand how RustFS uses OpenID Connect providers for Console single sign-on." +description: "Verstehen Sie, wie RustFS OpenID-Connect-Anbieter für das Single Sign-On der Console verwendet." --- -RustFS supports OpenID Connect (OIDC) for Console single sign-on. Use this overview to understand the authentication flow, prepare an identity provider, and choose a provider-specific configuration guide. +RustFS unterstützt OpenID Connect (OIDC) für das Single Sign-On der Console. Dieser Überblick erklärt den Authentifizierungsablauf, die Vorbereitung eines Identitätsanbieters und die anbieterspezifischen Konfigurationsanleitungen. -## How OIDC works +## Funktionsweise von OIDC -RustFS uses the OIDC Authorization Code Flow with Proof Key for Code Exchange (PKCE): +RustFS verwendet den OIDC Authorization Code Flow mit Proof Key for Code Exchange (PKCE): -1. RustFS sends an authorization request with an S256 PKCE challenge. -2. The identity provider authenticates you and returns an authorization code to the RustFS callback URL. -3. RustFS exchanges the code at the provider's token endpoint. -4. RustFS verifies the ID token signature, issuer, audience, expiry, and nonce. -5. RustFS maps configured token claims to local Identity and Access Management (IAM) policies and creates a Console session with temporary credentials. +1. RustFS sendet eine Autorisierungsanfrage mit einer S256-PKCE-Challenge. +2. Der Identitätsanbieter authentifiziert Sie und gibt einen Autorisierungscode an die Callback-URL von RustFS zurück. +3. RustFS tauscht den Code am Token-Endpunkt des Anbieters ein. +4. RustFS prüft Signatur, Aussteller, Zielgruppe, Ablauf und Nonce des ID-Tokens. +5. RustFS ordnet konfigurierte Token-Claims lokalen Richtlinien der Identitäts- und Zugriffsverwaltung (IAM) zu und erstellt eine Console-Sitzung mit temporären Zugangsdaten. -The identity provider authenticates you, while RustFS policies authorize S3 and administration operations. +Der Identitätsanbieter authentifiziert Sie; die RustFS-Richtlinien autorisieren S3- und Verwaltungsoperationen. -## Provider requirements +## Anforderungen an den Anbieter -Before configuring a provider, prepare: +Bereiten Sie vor der Konfiguration eines Anbieters Folgendes vor: -- An OIDC discovery URL that exposes the authorization, token, and JSON Web Key Set (JWKS) endpoints. -- A confidential client that supports the Authorization Code Flow, S256 PKCE, and client-secret authentication in the token request body. -- An exact callback URL in the form `https:///rustfs/admin/v3/oidc/callback/`. -- A public HTTPS origin for the RustFS Console. -- A flat group or role claim whose values match existing RustFS policy names. +- Eine OIDC-Discovery-URL, die die Endpunkte für Autorisierung, Token und das JSON Web Key Set (JWKS) bereitstellt. +- Einen vertraulichen Client, der den Authorization Code Flow, S256-PKCE und die Authentifizierung mit dem Client-Secret im Body der Token-Anfrage unterstützt. +- Eine exakte Callback-URL in der Form `https:///rustfs/admin/v3/oidc/callback/`. +- Einen öffentlichen HTTPS-Origin für die RustFS Console. +- Einen flachen Gruppen- oder Rollen-Claim, dessen Werte vorhandenen Namen von RustFS-Richtlinien entsprechen. -Use a dedicated client for RustFS and grant each identity only the policies it requires. +Verwenden Sie einen eigenen Client für RustFS und weisen Sie jeder Identität nur die Richtlinien zu, die sie benötigt. -## Provider guides +## Anleitungen zu Anbietern -- [Configure Keycloak](/security-compliance/oidc/keycloak) as an OIDC provider for the RustFS Console. -- [Configure GitLab](/security-compliance/oidc/gitlab) as an OIDC provider for the RustFS Console. +- [Keycloak konfigurieren](/de/security-compliance/oidc/keycloak) als OIDC-Anbieter für die RustFS Console. +- [GitLab konfigurieren](/de/security-compliance/oidc/gitlab) als OIDC-Anbieter für die RustFS Console. -## Next steps +## Nächste Schritte -- Review [users, groups, and policies](/security-compliance/iam/policies) before mapping identity-provider claims. -- Review the [Console security notes](/administration/console) before exposing the login endpoint publicly. +- Lesen Sie [Benutzer, Gruppen und Richtlinien](/de/security-compliance/iam/policies), bevor Sie Claims des Identitätsanbieters zuordnen. +- Lesen Sie die [Sicherheitshinweise zur Console](/de/administration/console), bevor Sie den Anmeldeendpunkt öffentlich bereitstellen. diff --git a/content/de/troubleshooting/driver.md b/content/de/troubleshooting/driver.md index f0d48390f..e6e16b42b 100644 --- a/content/de/troubleshooting/driver.md +++ b/content/de/troubleshooting/driver.md @@ -1,34 +1,25 @@ --- -title: "Hard Drive Failures" -description: "RustFS ensures read/write access can still be provided when some disks fail through mechanisms similar to erasure coding, and automatically heals data after replacing disks." +title: "Laufwerksausfälle" +description: "Ersetzen Sie ein ausgefallenes Laufwerk in einer RustFS-Bereitstellung und lassen Sie RustFS die Daten automatisch wiederherstellen." --- -RustFS ensures read/write access can still be provided when some disks fail through mechanisms similar to erasure coding, and automatically heals data after replacing disks. - -## Table of Contents - -1. [Unmount Failed Disk](#unmount-failed-disk) -2. [Replace Failed Disk](#replace-failed-disk) -3. [Update `/etc/fstab` or RustFS Configuration](#update-etcfstab-or-rustfs-configuration) -4. [Remount New Disk](#remount-new-disk) -5. [Trigger and Monitor Data Healing](#trigger-and-monitor-data-healing) -6. [Follow-up Checks and Notes](#follow-up-checks-and-notes) +RustFS verwendet Erasure Coding, damit Daten lesbar und schreibbar bleiben, wenn einzelne Laufwerke ausfallen. Nachdem Sie ein ausgefallenes Laufwerk ersetzt haben, stellt RustFS die fehlenden Daten automatisch darauf wieder her (Healing). -### Unmount Failed Disk +### Ausgefallenes Laufwerk aushängen -Before replacing the physical hard drive, you need to safely unmount the failed disk from the operating system level to avoid I/O errors in the file system or RustFS during the replacement process. +Hängen Sie das ausgefallene Laufwerk auf Betriebssystemebene aus, bevor Sie die physische Festplatte ersetzen. So vermeiden Sie I/O-Fehler im Dateisystem oder in RustFS während des Austauschs. ```bash # Assume the failed disk is /dev/sdb umount /dev/sdb ``` -:::note[Notes] +:::note[Hinweise] -* If there are multiple mount points, execute `umount` separately. -* If encountering "device is busy", you can first stop the RustFS service: +* Wenn das Laufwerk mehrere Einhängepunkte hat, führen Sie `umount` für jeden aus. +* Wenn Sie den Fehler „device is busy“ sehen, stoppen Sie zuerst den RustFS-Dienst: ```bash systemctl stop rustfs @@ -38,26 +29,28 @@ systemctl stop rustfs -### Replace Failed Disk +### Ausgefallenes Laufwerk ersetzen -After physically replacing the failed disk, you need to partition and format the new disk, and apply the same label as the original disk. +Nachdem Sie das ausgefallene Laufwerk physisch ersetzt haben, partitionieren und formatieren Sie das neue Laufwerk und vergeben Sie dieselbe Bezeichnung wie beim ursprünglichen Laufwerk. ```bash # Format as XFS and apply the same label as the original disk (RustFS requires XFS, like the other disks in the deployment) mkfs.xfs -L DISK1 /dev/sdb ``` -> **Requirements** -> -> * New disk capacity ≥ original disk capacity; -> * File system type consistent with other disks (XFS, per the [installation guide](../installation/linux/index.md)); -> * Recommend using labels (LABEL) or UUID for mounting to ensure disk order is not affected by system restarts. +:::note[Anforderungen] + +* Das neue Laufwerk ist mindestens so groß wie das ursprüngliche Laufwerk. +* Verwenden Sie dasselbe Dateisystem wie bei den anderen Laufwerken (XFS; siehe die [Installationsanleitung](../installation/linux/index.md)). +* Wir empfehlen, Dateisysteme über die Bezeichnung (LABEL) oder die UUID einzuhängen, damit Einhängungen korrekt bleiben, wenn sich Gerätenamen nach einem Neustart ändern. + +::: -### Update `/etc/fstab` or RustFS Configuration +### `/etc/fstab` oder die RustFS-Konfiguration aktualisieren -Confirm that the mount item labels or UUIDs in `/etc/fstab` point to the new disk. The mount point must stay identical to the one listed in `RUSTFS_VOLUMES` (in `/etc/default/rustfs`), so the healed disk rejoins the cluster at the same path. +Prüfen Sie, dass Bezeichnungen oder UUIDs in den Einträgen von `/etc/fstab` auf das neue Laufwerk zeigen. Der Einhängepunkt muss mit dem in `RUSTFS_VOLUMES` (in `/etc/default/rustfs`) genannten identisch bleiben, damit das wiederhergestellte Laufwerk dem Cluster unter demselben Pfad beitritt. ```bash # View current fstab @@ -67,16 +60,16 @@ cat /etc/fstab LABEL=DISK1 /data/rustfs0 xfs defaults,noatime 0 2 ``` -:::tip[Tips] +:::tip[Tipps] -* If using UUID: +* Bei Verwendung einer UUID: ```bash blkid /dev/sdb # Get the new partition's UUID, then replace the corresponding field in fstab ``` -* After modifying fstab, be sure to validate syntax: +* Nachdem Sie `/etc/fstab` bearbeitet haben, prüfen Sie die Syntax: ```bash mount -a # If no errors, configuration is correct @@ -86,32 +79,32 @@ mount -a # If no errors, configuration is correct -### Remount New Disk +### Neues Laufwerk wieder einhängen -Execute the following commands to batch mount all disks and start the RustFS service: +Führen Sie die folgenden Befehle aus, um alle konfigurierten Dateisysteme einzuhängen und RustFS zu starten: ```bash mount -a systemctl start rustfs ``` -Confirm all disks are mounted normally: +Prüfen Sie, dass alle erwarteten Dateisysteme eingehängt sind: ```bash df -h | grep /data/rustfs ``` -:::note +:::note[Fehler beim Einhängen] -If some mounts fail, please check if fstab entries are consistent with disk labels/UUIDs. +Wenn ein Einhängen fehlschlägt, prüfen Sie, dass Bezeichnungen oder UUIDs in `/etc/fstab` denen des Zieldateisystems entsprechen. ::: -### Trigger and Monitor Data Healing +### Datenwiederherstellung auslösen und beobachten -Once RustFS detects a freshly formatted disk at a known mount point, its background scanner heals the missing data onto it automatically — no manual command is required. Confirm that recovery has started and track its progress through the service logs: +Sobald RustFS an einem bekannten Einhängepunkt ein frisch formatiertes Laufwerk erkennt, stellt der Hintergrund-Scanner die fehlenden Daten automatisch darauf wieder her. Ein manueller Befehl ist nicht erforderlich. Bestätigen Sie, dass die Wiederherstellung begonnen hat, und verfolgen Sie den Fortschritt in den Dienstprotokollen: ```bash # For systemd-managed installations @@ -121,28 +114,28 @@ journalctl -u rustfs -f tail -f /var/log/rustfs/rustfs.log ``` -You can also open the RustFS Console and check the disk status of the affected node. +Sie können auch die RustFS Console öffnen und den Festplattenstatus des betroffenen Knotens prüfen. -:::note[Notes] +:::note[Hinweise] -* The healing process will complete in the background, usually with minimal impact on online access; -* After healing is complete, the tool will report success or list failed objects. +* Die Datenwiederherstellung läuft im Hintergrund und wirkt sich in der Regel wenig auf Client-Anfragen aus. +* Wenn die Datenwiederherstellung endet, melden die Protokolle den Erfolg oder listen Objekte, deren Wiederherstellung fehlgeschlagen ist. ::: -### Follow-up Checks and Notes +### Anschlussprüfungen und Hinweise -1. **Performance Monitoring** +1. **Leistungsüberwachung** - * I/O may fluctuate slightly during healing, recommend monitoring disk and network load. -2. **Batch Failures** + * Die I/O-Last kann während der Datenwiederherstellung schwanken. Wir empfehlen, die Auslastung von Festplatte und Netzwerk zu überwachen. +2. **Ausfälle einer Charge** - * If multiple failures occur in the same batch of disks, consider more frequent hardware inspections. -3. **Regular Drills** + * Wenn mehrere Laufwerke derselben Fertigungscharge ausfallen, prüfen Sie die übrigen Laufwerke dieser Charge häufiger. +3. **Regelmäßige Ausfalltests** - * Regularly simulate disk failure drills to ensure team familiarity with recovery processes. -4. **Maintenance Windows** + * Führen Sie regelmäßig Übungen zum Laufwerksausfall durch, damit Ihr Team das Wiederherstellungsverfahren proben kann. +4. **Wartungsfenster** - * When failure rates are high, arrange dedicated maintenance windows to speed up replacement and healing. + * Planen Sie bei hoher Ausfallrate eigene Wartungsfenster, um Austausch und Datenwiederherstellung zu beschleunigen. diff --git a/content/de/troubleshooting/index.md b/content/de/troubleshooting/index.md index 2d67143db..cd9d48e88 100644 --- a/content/de/troubleshooting/index.md +++ b/content/de/troubleshooting/index.md @@ -1,11 +1,10 @@ --- -title: "Troubleshooting" -description: "Diagnose and resolve RustFS issues." +title: "Fehlerbehebung" +description: "Diagnostizieren und beheben Sie Probleme mit RustFS." --- -Contents: - -- [Node Failures](./node.md) -- [Driver Failures](./driver.md) -- [Node Healing](../operations/high-availability/node-healing.md) +Dieser Abschnitt behandelt: +- [Knotenausfälle](./node.md) +- [Laufwerksausfälle](./driver.md) +- [Datenwiederherstellung eines Knotens](../operations/high-availability/node-healing.md) diff --git a/content/de/troubleshooting/node.md b/content/de/troubleshooting/node.md index 34f8fe953..067aeb497 100644 --- a/content/de/troubleshooting/node.md +++ b/content/de/troubleshooting/node.md @@ -1,83 +1,83 @@ --- -title: "Node Failures" -description: "Complete steps for handling node failures in RustFS clusters. Mainly includes: replacement node hardware preparation, configuration updates, service deployment, rejoining the cluster, data healing, and subsequent checks and best practices." +title: "Knotenausfälle" +description: "Bereiten Sie einen Ersatzknoten vor, aktualisieren Sie seine Konfiguration, stellen Sie die Cluster-Mitgliedschaft wieder her und prüfen Sie die Datenwiederherstellung." --- -In distributed RustFS clusters, erasure coding mechanisms are adopted to ensure read/write access can still be provided when some nodes fail, and automatic data healing occurs after nodes rejoin. This document will guide you through the following process: +Ein verteiltes RustFS-Cluster verwendet Erasure Coding, um lesbar und schreibbar zu bleiben, wenn einzelne Knoten ausfallen, und stellt Daten automatisch wieder her (Healing), wenn ein Knoten wieder beitritt. In dieser Anleitung führen Sie die folgenden Schritte aus: -1. Start replacement node and synchronize environment -2. Update DNS/hostname to point old node identifiers to new nodes -3. Download and deploy RustFS services consistent with the cluster -4. Rejoin new nodes to the cluster and trigger data healing -5. Monitor healing progress and perform subsequent checks and optimization +1. Starten Sie den Ersatzknoten und gleichen Sie seine Softwareumgebung an das Cluster an. +2. Aktualisieren Sie DNS oder `/etc/hosts`, damit der bisherige Hostname auf den neuen Knoten zeigt. +3. Installieren Sie dieselbe RustFS-Version wie auf den anderen Knoten. +4. Starten Sie die Ersatzknoten, damit sie dem Cluster wieder beitreten und die Datenwiederherstellung beginnt. +5. Beobachten Sie den Fortschritt der Datenwiederherstellung und führen Sie anschließend weitere Prüfungen aus. -## 1) Start Replacement Node +## 1. Ersatzknoten vorbereiten -* **Hardware and System Preparation** - Ensure the replacement node server hardware is roughly consistent with the failed node, including CPU, memory, network configuration, and disk type; even using higher configurations won't affect cluster performance. - Software environment needs to maintain version consistency with other nodes (operating system, kernel, dependency libraries, etc.) to avoid cluster abnormal behavior caused by environment differences. +* **Hardware und System vorbereiten** + Stellen Sie sicher, dass die Hardware des Ersatzknotens (CPU, Arbeitsspeicher, Netzwerk und Laufwerkstyp) ungefähr dem ausgefallenen Knoten entspricht. Leistungsstärkere Hardware beeinträchtigt die Leistung des Clusters nicht. + Verwenden Sie Softwareversionen, die zu den anderen Knoten passen, darunter Betriebssystem, Kernel und Abhängigkeiten, damit abweichende Umgebungen keine Probleme verursachen. -* **Drive Exclusive Access** - As with physical drive operations, RustFS requires exclusive access to storage volumes, prohibiting any other processes or scripts from directly modifying data within storage volumes, otherwise data corruption or redundancy loss can easily occur. +* **Exklusiver Zugriff auf Laufwerke** + Wie bei Operationen an physischen Laufwerken benötigt RustFS exklusiven Zugriff auf seine Speicher-Volumes. Lassen Sie andere Prozesse oder Skripte die Daten auf diesen Volumes nicht direkt ändern. Das kann Daten beschädigen oder die Redundanz verringern. -## 2) Update Hostname and Network Resolution +## 2. Hostname und Namensauflösung aktualisieren -* **DNS/Hosts Configuration** - If the replacement node's IP address differs from the failed node, you need to re-resolve the old node's hostname (such as `rustfs-node-2.example.net`) to the new node to ensure nodes within the cluster discover each other through the same address. +* **DNS- und Hosts-Konfiguration** + Wenn die IP-Adresse des Ersatzknotens von der des ausgefallenen Knotens abweicht, lassen Sie den bisherigen Hostnamen (zum Beispiel `rustfs-node-2.example.net`) auf die IP-Adresse des neuen Knotens zeigen, damit die Knoten des Clusters einander weiterhin unter demselben Namen erreichen. ```bash # Example: Add or modify line in /etc/hosts 192.168.1.12 rustfs-node-2.example.net ``` - After correct resolution, you can verify the hostname points to the new node through `ping` or `nslookup`. + Prüfen Sie mit `ping` oder `nslookup`, dass der Hostname auf den neuen Knoten zeigt. -## 3) Deploy and Configure RustFS Services +## 3. RustFS-Dienste bereitstellen und konfigurieren -* **Download and Installation** - Follow the same version deployment process as RustFS official, download binaries or installation packages consistent with existing nodes, and extract to a unified directory. Ensure startup scripts, environment variables, and configuration files (such as `/etc/default/rustfs`) are completely consistent with other nodes in the cluster. +* **Herunterladen und Installation** + Installieren Sie dieselbe RustFS-Version wie auf den vorhandenen Knoten, mit derselben Installationsmethode und demselben Verzeichnis. Stellen Sie sicher, dass Startskripte, Umgebungsvariablen und Konfigurationsdateien (etwa `/etc/default/rustfs`) mit denen der anderen Knoten übereinstimmen. -* **Configuration Verification** +* **Konfiguration prüfen** - * Check that `RUSTFS_VOLUMES` in `/etc/default/rustfs` is byte-for-byte identical to the other nodes, and that it covers the replacement node's hostname and port. - * Ensure all nodes have the same access keys and permission configurations to avoid new nodes being unable to join due to authentication failures. + * Prüfen Sie, dass `RUSTFS_VOLUMES` in `/etc/default/rustfs` bytegenau mit den anderen Knoten übereinstimmt und Hostname sowie Port des Ersatzknotens abdeckt. + * Stellen Sie sicher, dass alle Knoten dieselben Zugriffsschlüssel und Berechtigungseinstellungen verwenden. Andernfalls schlägt die Authentifizierung des neuen Knotens fehl und er kann dem Cluster nicht beitreten. -## 4) Rejoin Cluster and Trigger Data Healing +## 4. Dem Cluster wieder beitreten und die Datenwiederherstellung auslösen -* **Start Service** +* **Dienst starten** ```bash systemctl start rustfs ``` - Or use your custom startup script to start RustFS services, and view startup logs through `journalctl -u rustfs -f` to confirm the new node has detected other online nodes and started the data healing process. + Alternativ starten Sie RustFS mit Ihrem eigenen Startskript. Führen Sie anschließend `journalctl -u rustfs -f` aus, um zu bestätigen, dass der neue Knoten die anderen Knoten erkannt hat und die Datenwiederherstellung begonnen hat. -* **Monitor Healing Status** - Healing runs in the background once the node rejoins; no manual command is required. Watch its progress through the service logs on the replacement node, and check node and disk status in the RustFS Console: +* **Status der Datenwiederherstellung beobachten** + Die Datenwiederherstellung läuft im Hintergrund, sobald der Knoten wieder beitritt; ein manueller Befehl ist nicht erforderlich. Verfolgen Sie den Fortschritt in den Dienstprotokollen des Ersatzknotens und prüfen Sie Knoten- und Festplattenstatus in der RustFS Console: ```bash journalctl -u rustfs -f ``` -* **Community Experience Reference** - Community testing shows that when nodes go offline and rejoin, RustFS will only perform healing operations on new nodes, not fully rebalance the cluster, thus avoiding unnecessary network and I/O peaks. +* **Beobachtungen aus der Community** + In Tests der Community stellt RustFS nach dem Offline-Gehen und Wiederbeitritt eines Knotens nur diesen Knoten wieder her, statt das gesamte Cluster neu zu verteilen (Rebalancing). Das vermeidet unnötige Spitzen bei Netzwerk und I/O. -## 5) Subsequent Checks and Best Practices +## 5. Anschlussprüfungen und bewährte Vorgehensweisen -* **Monitoring and Alerts** +* **Überwachung und Alarme** - * During healing, monitor disk and network load to ensure the cluster meets read/write and network bandwidth requirements. - * Set up alerts to notify operations teams when node healing fails or progress stalls beyond thresholds. + * Überwachen Sie während der Datenwiederherstellung die Last von Festplatte und Netzwerk, damit das Cluster seine Anforderungen an Lesezugriff, Schreibzugriff und Bandbreite weiterhin erfüllt. + * Richten Sie Alarme ein, die Betriebsteams benachrichtigen, wenn die Datenwiederherstellung eines Knotens fehlschlägt oder der Fortschritt über festgelegte Schwellen hinaus stockt. -* **Repeated Failure Drills** - Regularly simulate node failures and drill the entire recovery process to ensure team familiarity with operation commands and emergency procedures. +* **Regelmäßige Ausfalltests** + Führen Sie regelmäßig Übungen zum Knotenausfall durch und proben Sie das vollständige Wiederherstellungsverfahren, damit Ihr Team die Befehle und den Ablauf bei einem Vorfall kennt. -* **Root Cause Analysis** - Conduct in-depth hardware health diagnostics (SMART, BIOS logs, etc.) on frequently failing nodes or disks, and implement preventive maintenance plans. +* **Ursachenanalyse** + Führen Sie eine ausführliche Hardwarediagnose (zum Beispiel SMART-Daten und BIOS-Protokolle) an Knoten oder Festplatten durch, die wiederholt ausfallen, und setzen Sie einen Plan für vorbeugende Wartung um. -* **Professional Support** - If deeper-level fault location and recovery guidance is needed, contact the RustFS development team or community for help. +* **Professionelle Unterstützung** + Wenden Sie sich zur Ursachenklärung eines Ausfalls oder zur Wiederherstellung des Clusters an das RustFS-Entwicklungsteam oder die Community. --- -**Summary**: Through the above process, RustFS can quickly and safely replace nodes and complete data healing after node hardware completely fails, minimizing cluster availability interruptions. Be sure to cross-reference with your own environment and specific command-line tools to ensure configuration consistency and correct operation sequence. +Diese Schritte ersetzen einen ausgefallenen Knoten und stellen seine Daten wieder her. Passen Sie die Befehle an Ihre Umgebung an und halten Sie die Konfiguration auf allen Knoten identisch.