> ## Documentation Index
> Fetch the complete documentation index at: https://docs.controlplane.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Nextcloud

> Nextcloud file sync, sharing, calendars and contacts (WebDAV, CalDAV, CardDAV) on Control Plane. Web replicas plus a cron worker over bundled PostgreSQL (optionally HA) and Redis, files on a volume or S3. Deploys into an existing single-location GVC; three secrets must exist first.

## Overview

Nextcloud is a self-hosted file sync and sharing platform. It gives your team a web UI, desktop and mobile sync clients, public share links, and calendars and contacts over CalDAV and CardDAV, with every file mountable as a WebDAV drive. This template runs Nextcloud with a background-jobs worker, a bundled PostgreSQL (single-instance by default, highly available behind one flag) and a bundled Redis, with files on a shared volume or in an S3 bucket.

Nextcloud Server is licensed AGPL-3.0 and this is the free community edition. Above 500 users, Nextcloud's free push service for the mobile apps stops delivering notifications and the web UI shows a community-release notice.

> [!NOTE]
>
> **This template deploys into an existing GVC.** It does not create or manage one. Every resource lands in the GVC you install into. Use a GVC with **one location** and set `location` to it. The bundled PostgreSQL and Redis start in every location the GVC has; if `location` is not a location of your GVC, Nextcloud starts nothing.

### What Gets Created

| Resource | Name | Purpose | Optional |
| - | - | - | - |
| Workload | `RELEASE_NAME-nextcloud` | Web UI, WebDAV and sync clients on port 80 (standard, 1-10 replicas) | — |
| Workload | `RELEASE_NAME-nextcloud-cron` | Background jobs every 5 minutes (standard, 1 replica) | — |
| Volume set | `RELEASE_NAME-nextcloud-data` | Shared volume with `config/`, `custom_apps/` and, with local storage, all files | — |
| Workload | `RELEASE_NAME-postgres` | Single-instance PostgreSQL (stateful, 1 replica) | `postgres.enabled: true` (default) |
| Volume set | `RELEASE_NAME-pg-vs` | Persistent data for the single-instance PostgreSQL | `postgres.enabled: true` |
| Workload | `RELEASE_NAME-postgres-ha` | PostgreSQL cluster managed by Patroni (stateful, 3 replicas) | `postgresHA.enabled: true` |
| Workload | `RELEASE_NAME-postgres-ha-proxy` | HAProxy leader endpoint Nextcloud connects through | `postgresHA.enabled: true` |
| Workload | `RELEASE_NAME-etcd` | Consensus store for Patroni (stateful, 3 replicas) | `postgresHA.enabled: true` |
| Workload | `RELEASE_NAME-redis` | Password-protected Redis for file locks, cache and sessions (stateful, 1 replica) | `redis.enabled: true` (default) |
| Secret | `RELEASE_NAME-redis-config` | Redis configuration | `redis.enabled: true` |
| Identity + Policy | `RELEASE_NAME-nextcloud-identity`, `RELEASE_NAME-nextcloud-policy` | Grants Nextcloud `reveal` on exactly the secrets it reads | — |
| Policy | `RELEASE_NAME-nextcloud-gvc-policy` | `view` on its own GVC, for the boot-time location check | — |
| Identity + Policy | `RELEASE_NAME-pg-identity`, `RELEASE_NAME-pg-policy` | Least-privilege access for the single-instance PostgreSQL | `postgres.enabled: true` |
| Identity + Policy | `RELEASE_NAME-redis-identity`, `RELEASE_NAME-redis-policy` | Least-privilege access for Redis | `redis.enabled: true` |

With `postgresHA.enabled: true` the HA workloads also get their own volume sets, identities and policies. With `storage.type: s3` and AWS the Nextcloud identity is linked to your cloud account.

## Prerequisites

**Three dictionary secrets must exist before you install**, in a GVC with one location. The template creates none of them; it references yours by name and grants Nextcloud `reveal` on exactly those secrets.

**1. Create the admin login secret**

A dictionary secret with the keys `username` and `password` (10 or more characters) of the first administrator. It is read on the first boot only.

```bash theme={null}
cpln secret create-dictionary --name ADMIN_SECRET_NAME \
  --entry username=admin \
  --entry password="$(openssl rand -hex 16)"
```

Set `admin.secretName` to this name.

**2. Create the database credentials secret**

A dictionary secret with `username`, `password` and `database`. The bundled PostgreSQL initializes with them and Nextcloud connects with them.

```bash theme={null}
cpln secret create-dictionary --name DB_CREDENTIALS_SECRET_NAME \
  --entry username=nextcloud \
  --entry password="$(openssl rand -hex 24)" \
  --entry database=nextcloud
```

Set `postgres.config.credentialsSecretName` (default) or `postgresHA.config.credentialsSecretName` (HA) to this name.

**3. Create the Redis password secret**

A dictionary secret with the key `password`. Use a hex value: Nextcloud reads it through PHP settings, where some punctuation has a meaning.

```bash theme={null}
cpln secret create-dictionary --name REDIS_SECRET_NAME \
  --entry password="$(openssl rand -hex 32)"
```

Set `redis.redis.auth.fromSecret.name` to this name.

> [!WARNING]
>
> **A missing prerequisite secret wedges the install silently.** The install exits 0, every resource is created, and Nextcloud then waits. Because the container never ran, `cpln logs` returns nothing.
>
> The only place the missing secret is named is `status.versions[].message`:
>
> ```bash theme={null}
> cpln workload get-deployments RELEASE_NAME-nextcloud --gvc GVC_NAME -o yaml
> ```
>
> It is **`get-deployments`**: plain `cpln workload get` has no `versions` key. If you create the secret after installing, force a redeployment of both Nextcloud workloads; they do not pick it up on their own:
>
> ```bash theme={null}
> cpln workload force-redeployment RELEASE_NAME-nextcloud --gvc GVC_NAME
> cpln workload force-redeployment RELEASE_NAME-nextcloud-cron --gvc GVC_NAME
> ```

**S3 file storage and database backups (optional).** A bucket for files is described under [Storage Setup](#storage-setup); backup buckets are described under [Backing Up](#backing-up).

## Installation

Install from the marketplace registry, naming your three secrets and the one location of your GVC:

```bash theme={null}
cpln helm install RELEASE_NAME oci://ghcr.io/controlplane-com/templates/nextcloud \
  --version 1.0.0 --gvc GVC_NAME \
  --set location=LOCATION_NAME \
  --set admin.secretName=ADMIN_SECRET_NAME \
  --set postgres.config.credentialsSecretName=DB_CREDENTIALS_SECRET_NAME \
  --set redis.redis.auth.fromSecret.name=REDIS_SECRET_NAME
```

Choose `storage.type` now: it cannot be changed after install. For the highly available database set `postgres.enabled=false`, `postgresHA.enabled=true` and `postgresHA.config.credentialsSecretName` instead of the `postgres` one.

To install using another method, follow the instructions for your preferred tool:

> [card] [UI](https://docs.controlplane.com/template-catalog/install-manage/ui.md)
>
> Browse, install, and manage templates visually

> [card] [CLI](https://docs.controlplane.com/template-catalog/install-manage/cli.md)
>
> Manage templates from your terminal

> [card] [Terraform](https://docs.controlplane.com/template-catalog/install-manage/terraform.md)
>
> Declare templates in your Terraform configurations

> [card] [Pulumi](https://docs.controlplane.com/template-catalog/install-manage/pulumi.md)
>
> Declare templates in your Pulumi programs

## Configuration

### Location and Nextcloud

```yaml theme={null}
# The ONE location of your GVC that Nextcloud runs in; it must already be a GVC location.
location: aws-us-east-1

nextcloud:
  image: nextcloud:34.0.5-apache   # one major version at a time on upgrade; never downgrade
  # 1-10 interchangeable replicas; 2+ needs redis.enabled: true (shared sessions and file locks)
  # set nextcloud.replicas: 2 and postgresHA.enabled: true for near-zero-downtime restarts and failover
  replicas: 1
  publicUrl: ""                    # empty = canonical endpoint; custom domain with scheme, e.g. https://cloud.example.com
  maxRequestWorkers: 20            # Apache workers per replica (~100 MiB each); raise with resources.maxMemory
  php:
    memoryLimit: 512M              # PHP memory_limit (minimum 512M)
  uploads:
    maxSize: 16G                   # largest single request body; browser uploads are chunked and not bound by it
  resources:
    minCpu: 500m
    maxCpu: 2000m
    minMemory: 1Gi
    maxMemory: 2Gi
```

### Background Jobs

```yaml theme={null}
cron:
  resources:
    minCpu: 100m
    maxCpu: 1000m
    minMemory: 256Mi
    maxMemory: 1Gi
```

### Admin Account and Volume

```yaml theme={null}
# REQUIRED — MUST EXIST BEFORE INSTALL, or the deployment WEDGES silently. A `dictionary` with the
# keys username and password (10+ characters). Read on first boot only.
admin:
  secretName: my-nextcloud-admin

# Shared by every replica and the cron worker: config, installed apps and (storage.type local) all files.
# Not snapshotted; deleted on uninstall.
volumeset:
  capacity: 10                     # GiB (minimum 10)
```

### File Storage

```yaml theme={null}
storage:
  type: local                      # local (the volume above) | s3 — fixed at install, cannot be switched later
  s3:
    bucket: my-nextcloud-bucket
    region: us-east-1
    endpoint: ""                   # S3-compatible servers only, e.g. http://my-minio.GVC.cpln.local:9000
    usePathStyle: false            # true for most S3-compatible servers (MinIO)
    cloudAccountName: my-nextcloud-cloud-account   # AWS keyless auth (used when auth.secretName is empty)
    policyName: my-nextcloud-s3-policy             # your bucket-scoped IAM policy (README Storage setup)
    auth:
      secretName: ""               # S3-compatible servers only: dictionary with accessKeyId + secretAccessKey, e.g. my-nextcloud-s3-keys
```

`storage.type: local` keeps every file on the shared volume. `storage.type: s3` keeps files in your bucket as objects named `urn:oid:<id>`, so the bucket is not browsable as a folder tree. See [Storage Setup](#storage-setup) for the bucket and credentials.

### Access

```yaml theme={null}
publicAccess:
  enabled: true                    # web UI, WebDAV and sync clients on the canonical *.cpln.app endpoint
internalAccess:
  type: same-gvc                   # none | same-gvc | same-org | workload-list
  workloads: []                    # workload-list only; this release's own workloads are always added
  # workloads:
  #   - //gvc/GVC_NAME/workload/WORKLOAD_NAME
```

### PostgreSQL

```yaml theme={null}
# set postgresHA.enabled: true (and postgres.enabled: false) for near-zero-downtime upgrades and failover
postgres:
  enabled: true
  image: postgres:18
  config:
    # REQUIRED — MUST EXIST BEFORE INSTALL, or the deployment WEDGES silently. A `dictionary` with the
    # keys username, password, database (see README Prerequisites).
    credentialsSecretName: my-nextcloud-db-credentials
  resources:
    minCpu: 250m
    maxCpu: 1000m
    minMemory: 512Mi
    maxMemory: 1Gi
  volumeset:
    capacity: 10                   # GiB (minimum 10)

  backup:                          # pass-through to the postgres template's backup feature
    enabled: false
    image: ghcr.io/controlplane-com/backup-images/postgres-backup:18.1.0   # tag must match the postgres major
    schedule: "0 2 * * *"          # daily at 02:00 UTC
    resources:
      cpu: 100m
      memory: 128Mi
    provider: aws                  # aws | gcp | minio
    aws:
      bucket: my-nextcloud-backup-bucket
      region: us-east-1
      cloudAccountName: my-nextcloud-backup-cloudaccount
      policyName: my-nextcloud-backup-policy
      prefix: nextcloud/backups
    gcp:
      bucket: my-nextcloud-backup-bucket
      cloudAccountName: my-nextcloud-backup-cloudaccount
      prefix: nextcloud/backups
    minio:
      endpoint: http://my-minio-workload:9000
      bucket: my-nextcloud-backup-bucket
      credentialsSecretName: my-nextcloud-minio-credentials   # provider minio only: dictionary with accessKey + secretKey
      prefix: nextcloud/backups
```

### Highly Available PostgreSQL

```yaml theme={null}
# 3 Patroni replicas, 3 etcd and an HAProxy leader endpoint; enable exactly one of postgres / postgresHA.
postgresHA:
  enabled: false
  config:
    # REQUIRED in HA mode — MUST EXIST BEFORE INSTALL. Same `dictionary` shape as postgres.config above.
    credentialsSecretName: my-nextcloud-db-credentials
  replicas: 3
  resources:
    minCpu: 500m
    maxCpu: 1000m
    minMemory: 1Gi
    maxMemory: 2Gi
  volumeset:
    capacity: 10                   # GiB per replica (minimum 10)

  backup:                          # pass-through to the postgres-highly-available template's backup feature
    enabled: false
    mode: logical                  # logical | wal-g
    resources:
      cpu: 100m
      memory: 512Mi                # wal-g backups need at least 512Mi
    logical:
      image: ghcr.io/controlplane-com/backup-images/postgres-backup:17.1.0
      schedule: "0 2 * * *"        # daily at 02:00 UTC
    walg:
      intervalSeconds: 21600       # every 6 hours
    provider: aws                  # aws | gcp | minio
    aws:
      bucket: my-nextcloud-backup-bucket
      region: us-east-1
      cloudAccountName: my-nextcloud-backup-cloudaccount
      policyName: my-nextcloud-backup-policy
      prefix: nextcloud/backups
    gcp:
      bucket: my-nextcloud-backup-bucket
      cloudAccountName: my-nextcloud-backup-cloudaccount
      prefix: nextcloud/backups
    minio:
      endpoint: http://my-minio-workload:9000
      bucket: my-nextcloud-backup-bucket
      credentialsSecretName: my-nextcloud-minio-credentials   # provider minio only: dictionary with accessKey + secretKey
      prefix: nextcloud/backups
```

### Redis

```yaml theme={null}
# Holds no data of record: file locks, cache and browser sessions only.
redis:
  enabled: true
  mode: dev                        # required — Nextcloud connects to one Redis endpoint
  redis:
    image: redis:8
    resources:
      maxCpu: 200m
      maxMemory: 256Mi
      minCpu: 80m
      minMemory: 128Mi
    auth:
      fromSecret:
        enabled: true              # required: Redis holds login sessions
        # REQUIRED when redis.enabled — MUST EXIST BEFORE INSTALL. A `dictionary` with the key
        # `password` (hex, e.g. openssl rand -hex 32).
        name: my-nextcloud-redis-password
        passwordKey: password
```

The `backup` blocks pass straight through to the [postgres](https://docs.controlplane.com/template-catalog/templates/postgres.md) and [postgres-highly-available](https://docs.controlplane.com/template-catalog/templates/postgres-highly-available.md) templates; their pages carry the bucket, cloud account and IAM policy setup.

### Storage Setup

Only for `storage.type: s3`. If Nextcloud cannot write to the bucket (a policy without `s3:PutObject`, a wrong key or a wrong endpoint), the first boot exits and restarts and Nextcloud never becomes reachable. The reason is in the logs:

```bash theme={null}
cpln logs '{gvc="GVC_NAME", workload="RELEASE_NAME-nextcloud"}' --limit 50 --since 10m
```

**AWS S3 (keyless).** Create the bucket and a Control Plane [cloud account](https://docs.controlplane.com/guides/create-cloud-account.md) for the AWS account, then create this IAM policy (replace `YOUR_BUCKET_NAME`). Set `storage.s3.cloudAccountName` and `storage.s3.policyName` to the cloud account and the policy.

```json theme={null}
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket", "s3:GetBucketLocation", "s3:ListBucketMultipartUploads"],
      "Resource": "arn:aws:s3:::YOUR_BUCKET_NAME"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject",
                 "s3:AbortMultipartUpload", "s3:ListMultipartUploadParts"],
      "Resource": "arn:aws:s3:::YOUR_BUCKET_NAME/*"
    }
  ]
}
```

**S3-compatible servers (MinIO and others).** Create the bucket and a dictionary secret with `accessKeyId` and `secretAccessKey`, then set `storage.s3.endpoint`, `storage.s3.usePathStyle: true` and `storage.s3.auth.secretName` to the secret name:

```bash theme={null}
cpln secret create-dictionary --name S3_CREDENTIALS_SECRET_NAME \
  --entry accessKeyId=ACCESS_KEY \
  --entry secretAccessKey=SECRET_KEY
```

The endpoint takes a scheme and host. For a server in the same GVC use its fully qualified internal name, for example `http://WORKLOAD_NAME.GVC_NAME.cpln.local:9000`. Static keys are written to `config.php` on the volume; keyless AWS writes none.

## Connecting

| Target | Address | Credentials |
| - | - | - |
| Web UI, WebDAV, sync clients | `status.canonicalEndpoint` of `cpln workload get RELEASE_NAME-nextcloud --gvc GVC_NAME -o yaml`, or `nextcloud.publicUrl` | the admin login |
| Private access | `cpln port-forward RELEASE_NAME-nextcloud 8080:80 --gvc GVC_NAME`, then `http://localhost:8080` | same |
| Internal | `http://RELEASE_NAME-nextcloud.GVC_NAME.cpln.local` | a user or app password |
| WebDAV files | `/remote.php/dav/files/USERNAME/` on any address above | same |
| CalDAV and CardDAV | the server address; clients discover `/.well-known/caldav` and `/.well-known/carddav` | a user or app password |
| PostgreSQL | `RELEASE_NAME-postgres.GVC_NAME.cpln.local:5432`, or `RELEASE_NAME-postgres-ha-proxy.GVC_NAME.cpln.local:5432` in HA mode | the database credentials secret |

Sign in with the admin login, then add users under **Accounts**. Desktop and mobile clients take the server address and sign in through the browser. For scripts and WebDAV mounts, create an app password under **Personal settings → Security**.

### Calendar and Contacts

CalDAV and CardDAV work out of the box, so calendar and contact clients connect to the `.well-known` URLs above. The **Calendar** and **Contacts** web apps are not installed by default: `/apps/calendar/` and `/apps/contacts/` return 404 until you install them. Install them with `occ`, one app per command:

```bash theme={null}
cpln workload exec RELEASE_NAME-nextcloud --gvc GVC_NAME --container nextcloud -- \
  setpriv --reuid=33 --regid=33 --init-groups php /var/www/html/occ app:install calendar

cpln workload exec RELEASE_NAME-nextcloud --gvc GVC_NAME --container nextcloud -- \
  setpriv --reuid=33 --regid=33 --init-groups php /var/www/html/occ app:install contacts
```

Or sign in as an administrator, open **Apps** from the profile menu and install **Calendar** and **Contacts** there. Apps live on the shared volume, so every replica sees them.

### Running occ

Run Nextcloud's `occ` command as `www-data` (uid 33), the owner of `config.php` and the data directory, so anything it writes stays readable by Nextcloud:

```bash theme={null}
cpln workload exec RELEASE_NAME-nextcloud --gvc GVC_NAME --container nextcloud -- \
  setpriv --reuid=33 --regid=33 --init-groups php /var/www/html/occ status
```

The admin password in the secret is read on the first boot only. Change it in **Personal settings**, or reset a forgotten one (`read` keeps it out of your shell history):

```bash theme={null}
read -rs NEW_PASSWORD
cpln workload exec RELEASE_NAME-nextcloud --gvc GVC_NAME --container nextcloud -- \
  env OC_PASS="$NEW_PASSWORD" setpriv --reuid=33 --regid=33 --init-groups \
  php /var/www/html/occ user:resetpassword --password-from-env admin
```

## Operations

### Backing Up

Three things make up an instance, and they are backed up separately:

* **The database** holds users, shares, calendars, contacts and the file index. Turn on `postgres.backup.enabled` or `postgresHA.backup.enabled` and follow the bucket and cloud account setup on the [postgres](https://docs.controlplane.com/template-catalog/templates/postgres.md) or [postgres-highly-available](https://docs.controlplane.com/template-catalog/templates/postgres-highly-available.md) page.
* **Files** are on the volume with `storage.type: local`, which is not snapshotted. With `storage.type: s3` they are in your bucket; back it up with your provider.
* **`config/config.php`** holds the instance `secret`, `passwordsalt` and `instanceid`, which exist only on the volume. Copy it out after the first install; see [Important Notes](#important-notes).

A database backup alone does not restore Nextcloud; it needs the saved `config.php` too.

### Scaling and Availability

Set `nextcloud.replicas` to 2 or more (up to 10) for more capacity and rolling restarts without downtime; this requires `redis.enabled: true`. Set `postgresHA.enabled: true` (and `postgres.enabled: false`) for a database that survives restarts and failover. Both together give near-zero-downtime restarts. Only one replica installs or upgrades Nextcloud at a time, and Nextcloud version upgrades always take it offline for a few minutes.

### Rotating Secrets

Each secret rotates differently:

* **Admin:** the secret is read on the first boot only. Reset the password as shown under [Running occ](#running-occ).
* **Database:** run `ALTER ROLE ... PASSWORD` first (in HA mode follow the [postgres-highly-available](https://docs.controlplane.com/template-catalog/templates/postgres-highly-available.md) rotation steps), then update the secret.
* **Redis:** update the value with `cpln secret edit REDIS_SECRET_NAME`, then force a redeployment of `RELEASE_NAME-redis`. The old password stops working, browser users may need to sign in again, and sync clients and app passwords carry on.

After a database or Redis change, force a redeployment of both Nextcloud workloads:

```bash theme={null}
cpln workload force-redeployment RELEASE_NAME-nextcloud --gvc GVC_NAME
cpln workload force-redeployment RELEASE_NAME-nextcloud-cron --gvc GVC_NAME
```

### Troubleshooting

> [accordion] No logs and the deployment never becomes ready
>
> A prerequisite secret is missing. Run `cpln workload get-deployments RELEASE_NAME-nextcloud --gvc GVC_NAME -o yaml` and read `status.versions[].message`. Create the secret and force a redeployment.

> [accordion] Deployment reports deactivated because maxScale is set to 0
>
> `location` is not a location of your GVC. Set `location` to a location the GVC already has.

> [accordion] First boot restarts in a loop with AccessDenied or SignatureDoesNotMatch
>
> With `storage.type: s3`, Nextcloud cannot write to the bucket. `AccessDenied` on `s3:PutObject` means the IAM policy lacks it; `SignatureDoesNotMatch` means the keys or endpoint are wrong. Read the cause with `cpln logs`, fix the policy or the secret, and redeploy.

> [accordion] HTTP 503 after an upgrade
>
> An `occ upgrade` was cut short and maintenance mode is still on. The next start resumes the upgrade. If the 503 lingers, run `occ maintenance:mode --off` as shown under [Running occ](#running-occ).

> [accordion] New replicas stop at boot after a storage change
>
> `storage.type` and `storage.s3.bucket` are fixed at install; a changed value stops new replicas while the old ones keep serving. Restore the original values.

## Important Notes

* **Copy `config/config.php` somewhere safe after the first install.** It holds the instance `secret`, `passwordsalt` and `instanceid`, which are on the volume only: a database backup cannot fully restore Nextcloud without them. It also holds the Redis password (and S3 keys, if set), so store it as a secret: `cpln workload exec RELEASE_NAME-nextcloud --gvc GVC_NAME --container nextcloud -- cat /srv/nextcloud/config/config.php > config.php`. The database password is never written to it.
* **The volume is not snapshotted and is deleted on uninstall,** with every file when `storage.type` is `local`. Use `storage.type: s3` for files that must outlive the release.
* **`storage.type` and `storage.s3.bucket` are fixed at install.** Nextcloud cannot move files between them.
* **Upgrade Nextcloud one major version at a time** and never downgrade. Upgrades run in maintenance mode (HTTP 503) for a few minutes, and the first `helm upgrade` can briefly restart the single-instance PostgreSQL, and Nextcloud with it; use `postgresHA` when that matters.
* **A single upload request must finish within 600 seconds.** Browser and desktop uploads are chunked; single `curl` or `rclone` PUTs are not.
* **Nextcloud's log goes to stderr:** read it with `cpln logs`; the Logging app's log viewer is empty.
* **Install into a GVC with one location** and set `location` to it.

## External References

> [card] [Nextcloud Administration Manual](https://docs.nextcloud.com/server/latest/admin_manual/)
>
> Official administration documentation

> [card] [occ Command Reference](https://docs.nextcloud.com/server/latest/admin_manual/occ_command.html)
>
> Command-line administration of Nextcloud

> [card] [Object Storage as Primary Storage](https://docs.nextcloud.com/server/latest/admin_manual/configuration_files/primary_storage.html)
>
> How Nextcloud stores files in S3

> [card] [Nextcloud Clients](https://nextcloud.com/install/#install-clients)
>
> Desktop and mobile sync clients

> [card] [Nextcloud Template](https://github.com/controlplane-com/templates/tree/main/nextcloud)
>
> View the source files, default values, and chart definition
