# Nextcloud auf Kubernetes einrichten - so geht's!

Wenn Sie Nextcloud auf Kubernetes einrichten möchten, sind ein S3 als Speicher-Backend sowie MariaDB als Datenbank empfehlenswert. Die Performance steigern Sie mit einigen Änderungen innerhalb der Konfiguration.

## Nextcloud und Kubernetes: Eine lohnende Kombination

Die Kombination von [Nextcloud](https://www.ionos.com/de-ch/digitalguide/server/tools/was-ist-nextcloud/) und Kubernetes mit S3 als Speicher-Backend ist in vielen Fällen eine erfolgsversprechende Lösung im privaten und geschäftlichen Bereich. Die **nichtkommerzielle Cloud-Software** ist für die Arbeit mit lokalen Servern ebenso wie mit externen Hosts geeignet und besticht auch im Vergleich zu zahlreichen Nextcloud-Alternativen durch eine hervorragende Sicherheitsarchitektur. Kubernetes ist ein Open-Source-Verwaltungssystem für Container-Anwendungen und kann neben der lokalen Nutzung auch für Cloud-Computing verwendet werden. Das System gilt als **äußerst flexibel, maximal skalierbar und sehr ausfallsicher**. Wir zeigen Ihnen, wie Sie Nextcloud auf Kubernetes einrichten.

Tipp Sie möchten Nextcloud mit Docker nutzen nutzen? Dazu finden Sie in unserem Digital Guide ebenfalls eine umfangreiche Anleitung. Auch die Nextcloud-Installation unter Ubuntu 20.04 und die entsprechenden Schritte für die [Nextcloud-Installation unter Ubuntu 22.04](https://www.ionos.com/de-ch/digitalguide/server/konfiguration/nextcloud-ubuntu-2204/) haben wir Ihnen zusammengestellt.

## Welche Voraussetzungen müssen erfüllt sein?

Bevor Sie damit beginnen können, Nextcloud auf Kubernetes einzurichten, müssen einige Voraussetzungen erfüllt sein. So benötigen Sie ausreichend Speicher und sollten bereits einen Kubernetes Cluster erstellt haben. Ob Sie diesen auf Ihrer lokalen Maschine anlegen oder dafür einen Cloud-Speicher verwenden, bleibt Ihnen überlassen und richtet sich nach den Kapazitäten, die Sie benötigen bzw. zur Verfügung haben. Auch der **Paketmanager Helm** sollte für Kubernetes eingerichtet sein. Ist dies der Fall, können Sie mit den einzelnen Schritten beginnen.

## Nextcloud auf Kubernetes einrichten: Die wichtigsten Schritte

Haben Sie die passende Basis geschaffen, können Sie mit der Einrichtung der Nextloud-Kubernetes-Kombination starten. Wir haben die wichtigsten Schritte in den nachfolgenden Abschnitten für Sie zusammengefasst.

### DNS konfigurieren

Im ersten Schritt legen Sie einen A-Record für eine Subdomain an, die auf Ihre gewünschte IP-Adresse verweisen kann. Setzen Sie auf die lokale Lösung, ist Ihre öffentliche IP-Adresse das richtige Ziel; ansonsten hinterlegen Sie die IP, die von Ihrem Cloud-Service zur Verfügung gestellt wird. Je nach DNS-Provider können sich die dafür nötigen Schritte ein wenig unterscheiden.

### Helm hinzufügen und updaten

Die Bereitstellung für Kubernetes erfolgt mit Hilfe des angesprochenen Paketmanagers Helm. Dieser sollte auf Ihrem Client installiert sein. Außerdem benötigen Sie eine Verbindung zu Ihrem Kubernetes-Cluster. Ist dies gegeben, fügen Sie das Helm-Repository hinzu und updaten es. Dafür nutzen Sie die folgenden beiden Befehle:

```shell
helm repo add nextcloud https://nextcloud.github.io/helm/
helm repo update
```

### values.yaml erstellen

Erstellen Sie nun ein neues Helmchart mit dem folgenden Befehl:

```shell
nano values.yaml
```

Fügen Sie danach die folgenden Spezifikationen in diese Datei ein.

### Cronjobs einstellen

Definieren Sie zunächst ein **Zeitlimit für Cronjobs**. Dies sind auf unixartigen Betriebssystemen Aufgaben, die automatisch im Hintergrund ausgeführt und wiederholt werden. Im Falle von Nextcloud auf Kubernetes handelt es sich dabei vor allem um Wartungsarbeiten. In unserem Beispiel weisen wir die Ausführung alle fünf Minuten an. Gerade bei größeren Datenvorkommen kann aber auch eine häufigere Wartung ratsam sein. Dies ist der passende Code:

```shell
cronjob:
    annotations: {}
    curlInsecure: false
    enabled: true
    failedJobsHistoryLimit: 5
    image: {}
    schedule: '*/5*     *** '
    successfulJobsHistoryLimit: 2
```

### HPA deaktivieren

Deaktivieren Sie nun HPA (Horizontal Pod Autoscaler). Dieser skaliert die Anzahl der Pods automatisch. Wenn Sie ReadWriteOnce für Nextcloud nutzen und die Skalierung selbst kontrollieren möchten, sollten Sie HPA ausstellen und sich dadurch auf einen Pod konzentrieren. Sofern nur wenige Userinnen und User auf die Daten zugreifen möchten, ist dies die deutlich bequemere Lösung. Der passende Code sieht aus wie folgt:

```shell
hpa:
    cputhreshold: 60
    enabled: false
    maxPods: 10
    minPods: 1
```

### Image-Tag überschreiben

Um sicherzustellen, dass die aktuelle Version von Helm berücksichtigt wird, überschreiben Sie den Image-Tag. Dafür verwenden Sie diesen Code:

```shell
image:
    repositor: nextcloud
    tag: 28.0.2-apache
    pullPolicy: IfNotPresent
```

Nun wird die Version 28.0.2 oder eine aktuellere ausgewählt.

### Datenbank auswählen

Bei der Auswahl Ihrer Datenbank haben Sie drei Optionen: MariaDB, PostgreSQL oder Sqlite. Für unser Beispiel entscheiden wir uns für MariaDB. Diese Datenbank konfigurieren Sie wie folgt und stellen die beiden anderen Systeme ab.

```shell
internalDatabase:
    enabled: false
mariadb:
    db:
        name: nextcloud
        password: db-password
        user: nextcloud
    enabled: true
    master:
        persistence:
            accessMode: ReadWriteOnce
            enabled: true
            size: 8Gi
    replication:
        enabled: false
    rootUser:
        password: root-db-password
        forcePassword: true
postgresql:
    enabled: false
```

### Monitoring für Metrics

Wenn Sie ein Monitoring mit Prometheus oder Grafana durchführen möchten, fügen Sie den folgenden Code ein. Dies ist optional.

```shell
metrics:
    enabled: true
    https: false
    image:
        pullPolicy: IfNotPresent
        repository: xperimental/nextcloud-exporter
        tag: v0.3.0
    replicaCount: 1
    service:
        annotations:
            prometheus.io/port: '9205'
            prometheus.io/scrape: 'true'
        labels: {}
        type: ClusterIP
    timeout: 5s
```

### Eigene Konfigurationsdateien erlauben

Standardmäßig nutzt Nextcloud auch auf Kubernetes eine Datei namens config.php für die Konfiguration. Möchten Sie dies vereinfachen oder flexibler gestalten, können Sie eigene Konfigurationsdateien einfügen. Dafür nutzen Sie den folgenden Code:

```shell
nextcloud:
    configs:
        custom.config.php: |-
            <?php
            $CONFIG = array (
                'overwriteprotocol' => 'https',
                'overwrite.cli.url' => 'https://drive.beispiel.com',
                'filelocking.enabled' => 'true',
                'loglevel' => '2',
                'enable_previews' => true,
                'trusted_domains' =>
                     [
                        'nextcloud',
                        'drive.beispiel.com'
                     ]
            );
```

Ersetzen Sie dafür den Platzhalter „beispiel.com“ mit Ihrer eigenen Domain.

### Redis konfigurieren

Die nächste eigene Konfigurationsdatei wird implementiert, um das Caching mit Redis und dadurch die gesamte Performance zu verbessern. Standardmäßig installiert Helm Redis ohne Passwortschutz. Es ist allerdings empfehlenswert, eine zusätzliche Sicherung einzubauen, auch weil dies spätere Probleme beim Einloggen verhindert. Diesen Code fügen Sie dafür ein:

```shell
redis.config.php: |-
    <?php
    $CONFIG = array (
      'memcache.local' => '\\OC\\Memcache\\Redis',
      'memcache.distributed' => '\OC\Memcache\Redis',
      'memcache.locking' => '\OC\Memcache\Redis',
      'redis' => array(
        'host' => getenv('REDIS_HOST'),
        'port' => getenv('REDIS_HOST_PORT') ?: 6379,
        'password' => getenv('ihr-passwort-für-redis')
      )
    );
```

### Speicher-Backend konfigurieren

Die letzte Konfigurationsdatei wird für das Speicher-Backend S3 eingefügt. Sie wird folgendermaßen im Code hinterlegt:

```shell
s3.config.php: |-
    <?php
    $CONFIG = array (
      'objectstore' => array(
        'class' => '\\OC\\Files\\ObjectStore\\S3',
        'arguments' => array(
        'bucket'     => 'bucket-name',
        'autocreate' => true,
        'key'      => 's3-access-key',
        'secret'     => 's3-secret-key',
        'region'     => 's3-region',
        'hostname'   => 's3-endpoint',
        'use_ssl'    => true,
        'use_path_style' => true
        )
      )
    );
```

### Redis-Konfiguration ausschalten

Da Sie weiter oben die standardmäßige Konfiguration für Redis überschrieben haben, muss diese nun deaktiviert werden, um Fehler zu vermeiden. Der dafür passende Code ist dieser:

```shell
defaultConfigs:
    .htaccess: true
    apache-pretty-urls.config.php: true
    apcu.config.php: true
    apps.config.php: true
    autoconfig.php: false
    redis.config.php: false
    smtp.config.php: true
```

### Host, Admin und Passwort festlegen

Nun hinterlegen Sie den Host, den Administrator und das entsprechende Passwort für die Nutzung von Nextcloud auf Kubernetes. Dafür verwenden Sie diesen Code:

```shell
host: drive.beispiel.com
password: ihr-passwort
username: name-des-admins
```

Ersetzen Sie dabei die Platzhalter durch Ihre eigenen Angaben.

### Benachrichtigungen per E-Mail einrichten

Sie können optional einen SMTP-Service (Simple Mail Transfer Protocol) aufsetzen, um von Nextcloud Benachrichtigungen zu erhalten. Dafür nutzen Sie diesen Code:

```shell
mail:
    domain: beispiel.com
    enabled: false
    fromAddress: user
    smtp:
      authtype: LOGIN
      host: beispiel.com
      name: username
      password: ihr-passwort
      port: 465
      secure: ssl
```

### Einstellung für das Persistence-Laufwerk

Die folgende Persistence-Konfiguration ist für Daten gedacht, die Nextcloud auf dem entsprechenden Datenträger speichert. Dies betrifft nicht Ihre Nutzerdaten, die planmäßig auf S3 hinterlegt werden.

```shell
persistence:
    accessMode: ReadWriteOnce
    annotations: {}
    enabled: true
    size: 8Gi
```

### Passwortschutz für Redis

Es ist empfehlenswert, Redis mit einem Passwort zu sichern. Dies beugt auch Fehlern bei der Authentifizierung vor. Der passende Code sieht so aus, wobei Sie Ihr persönliches Passwort an der entsprechenden Stelle ersetzen müssen:

```shell
redis:
    enabled: true
    password: 'ihr-passwort-für-redis'
    usePassword: true
```

### Replikationen beschränken

Da Sie weiter oben bereits HPA deaktiviert haben, sollten Sie die mögliche Anzahl der Replikationen auf 1 beschränken. Dies ist die Anweisung:

```shell
replicaCount: 1
```

### Nextcloud auf Kubernetes installieren

Abschließend installieren Sie Nexcloud auf Kubernetes und fügen auch MariaDB und Redis hinzu. Dies ist der Befehl:

```shell
kubectl create ns nextcloud
helm upgrade --install --namespace nextcloud -f your-values.yaml nextcloud nextcloud/nextcloud
```


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/server/konfiguration/nextcloud-kubernetes/](https://www.ionos.com/de-ch/digitalguide/server/konfiguration/nextcloud-kubernetes/) for AI/LLM consumption.