---
title: "NocoDB auf dem Synology NAS installieren: Airtable-Alternative auf eigener Datenbank"
date: 2026-09-11T13:55:27+02:00
modified: 2026-11-05T22:17:08+01:00
category: synology
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/nocodb-synology-airtable-alternative
reading_time: 11
personalize_url: "https://s-edv.com/anleitungen/nocodb-synology-airtable-alternative#volume={volume}"
variables:
  - name: volume
    label: "Synology-Volume"
    default: "volume1"
  - name: postgres_password
    label: "Passwort (postgres password)"
    generated_in_browser: true
  - name: nc_auth_jwt_secret
    label: "Schlüssel (nc auth jwt secret)"
    generated_in_browser: true
---

# NocoDB auf dem Synology NAS installieren: Airtable-Alternative auf eigener Datenbank

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{volume}}` | Synology-Volume | `volume1` |
| `{{postgres_password}}` | Passwort (postgres password) | wird im Browser des Lesers zufällig erzeugt |
| `{{nc_auth_jwt_secret}}` | Schlüssel (nc auth jwt secret) | wird im Browser des Lesers zufällig erzeugt |

Link mit eigenen Werten: https://s-edv.com/anleitungen/nocodb-synology-airtable-alternative#volume=volume2

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Wer relationale Daten intern verwalten möchte, etwa Inventarlisten, CRM-Kontakte, Projekttracking oder Onboarding-Formulare, steht vor der Wahl: Airtable mit laufenden Kosten und Abhängigkeit von einer US-Cloud oder ein eigenes Werkzeug auf eigener Hardware. NocoDB legt eine tabellenähnliche Oberfläche über eine PostgreSQL-Datenbank, bietet Kanban-, Galerie-, Formular- und Kalenderansichten und liefert eine vollständige REST-API mit. Das Projekt erscheint in monatlichen Releases (Stand Oktober 2026: 2026.10.1) und eignet sich für den internen Einsatz im Unternehmen. Diese Anleitung richtet einen Stack aus vier Containern auf Ihrem Synology NAS ein: PostgreSQL als Datenbank statt SQLite, Redis als Job-Queue und ein eigener Worker-Container für CSV-Importe und Automationen.

**Kurzfassung:** NocoDB ist eine selbst gehostete Airtable-Alternative und verbindet PostgreSQL mit einer No-Code-Tabellenoberfläche. Der Stack besteht aus vier Containern: nocodb, worker, PostgreSQL 17 und Redis 7. Sie richten alles als Compose-Projekt im Container Manager ein, setzen ein festes JWT-Secret und verbinden NocoDB per `NC_DB`-String mit PostgreSQL. Nach etwa 35 Minuten steht das Dashboard unter `http://NAS-IP:8631/dashboard` bereit, alle Daten bleiben auf Ihrer eigenen Hardware.

## Voraussetzungen

- [ ] Synology NAS mit DSM 7.2 oder neuer, Container Manager installiert
- [ ] Mindestens 2 GB freier RAM (empfohlen: 4 GB für den Stack mit PostgreSQL, Redis und Worker)
- [ ] Mindestens 10 GB freier Speicherplatz auf `/{{volume}}` für Datenbank und Anhänge
- [ ] SSH-Zugang zum NAS, nötig für Ordneranlage und Rechtevergabe (Anleitung: [SSH auf dem Synology NAS aktivieren und verbinden](https://s-edv.com/anleitungen/synology-ssh-aktivieren-putty-terminal-verbinden))
- [ ] Internetzugang für den Download der Images `nocodb/nocodb:latest`, `postgres:17.10`, `redis:7`
- [ ] Optional: Synology-DDNS-Adresse (`*.synology.me`) oder eigene Domain für HTTPS über einen Reverse Proxy

## Schritt 1: Ordnerstruktur anlegen und Rechte setzen

Die Ordner müssen vor dem Start existieren, sonst scheitert das Projekt mit `Bind mount failed`. Neue Ordner erben auf dem Synology NAS die ACL der Freigabe. Redis schreibt als UID 999 und darf das dann trotz passendem Besitzer nicht; der Befehl `chmod` entfernt die ACL. PostgreSQL setzt Besitzer und Rechte seines Ordners selbst, NocoDB schreibt als root. Legen Sie die Ordner per SSH an und setzen Sie die Rechte für Redis:

```bash
sudo mkdir -p /{{volume}}/docker/nocodb/{data,db,redis}
sudo chown -R 999:999 /{{volume}}/docker/nocodb/redis
sudo chmod -R 755 /{{volume}}/docker/nocodb/redis
```

Danach existieren drei Unterordner: `data` für NocoDB-Anhänge, `db` für die PostgreSQL-Dateien und `redis` für die Redis-Persistenz.

> Prüfen Sie per SSH, ob alle drei Ordner existieren:
>
> ```bash
> ls -la /{{volume}}/docker/nocodb/
> ```

Erwartet: drei Ordner (`data`, `db`, `redis`), `redis` mit dem Besitzer `999` und den Rechten `drwxr-xr-x`. Fehlt ein Ordner, wiederholen Sie `mkdir`.

## Schritt 2: JWT-Secret und Passwörter generieren

`NC_AUTH_JWT_SECRET` signiert die Anmelde-Token. Ohne diese Variable erzeugt NocoDB selbst ein Secret und speichert es in der Datenbank. Ein fest gesetzter Wert macht die Installation aber unabhängig vom Datenbankinhalt und gilt für nocodb und worker gleichermaßen. Erzeugen Sie einmalig einen Zufallswert und notieren Sie ihn sicher. Ändern Sie ihn später, werden alle Nutzer abgemeldet.

```bash
openssl rand -hex 32
```

Der Befehl liefert 32 Byte als 64 Hexzeichen, zum Beispiel:

```plaintext
a3f8c2e1d94b67f0123456789abcdef0a3f8c2e1d94b67f0123456789abcdef0
```

Erzeugen Sie außerdem ein Datenbankpasswort (mindestens 16 Zeichen, Groß- und Kleinbuchstaben, Zahlen) und ein Admin-Passwort. Verzichten Sie im Datenbankpasswort auf `&`, `?` und `@`, da es später Teil des `NC_DB`-Strings ist. Bewahren Sie alle Werte in einem Passwortmanager auf, etwa in [Vaultwarden auf der Synology](https://s-edv.com/anleitungen/vaultwarden-synology-passwortmanager-backup).

> **Prüfen:** Die Ausgabe ist genau 64 Zeichen lang und enthält nur `0-9` und `a-f`. Länge prüfen:
>
> ```bash
> openssl rand -hex 32 | wc -c
> ```

Erwartete Ausgabe: `65` (64 Zeichen plus Zeilenumbruch).

## Schritt 3: Compose-Datei erstellen und Projekt anlegen

Öffnen Sie im Container Manager den Bereich *Projekt* und klicken Sie auf *Erstellen*. Vergeben Sie den Projektnamen `nocodb` und wählen Sie über *Pfad festlegen* den Ordner `/docker/nocodb`. Das Vorgehen im Detail beschreibt [Container Manager: Docker-Compose-Projekt anlegen, starten und aktualisieren](https://s-edv.com/anleitungen/synology-container-manager-projekt-compose-anlegen).

Wählen Sie als Quelle *docker-compose.yml erstellen* und tragen Sie folgenden Inhalt ein. Er folgt dem offiziellen Beispiel *quickstart-demo* des Projekts. Ersetzen Sie `SICHERES_DB_PASSWORT`, `HIER_64_ZEICHEN_ZUFALLSSTRING_EINSETZEN`, `NAS-IP` sowie Admin-E-Mail und Admin-Passwort durch Ihre Werte:

```yaml
services:

  nocodb:
    image: nocodb/nocodb:latest
    container_name: nocodb
    environment:
      NC_DB: 'pg://db:5432?u=nocodb&p={{postgres_password}}&d=nocodb'
      NC_REDIS_URL: 'redis://redis:6379'
      NC_SITE_URL: 'http://NAS-IP:8631'
      NC_AUTH_JWT_SECRET: '{{nc_auth_jwt_secret}}'
      NC_ADMIN_EMAIL: 'admin@beispiel.de'
      NC_ADMIN_PASSWORD: 'SicheresAdmin!Passwort1'
      NC_DISABLE_TELE: 'true'
      NC_DISABLE_MUX: 'true'
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: unless-stopped
    ports:
      - '8631:8080'
    volumes:
      - /{{volume}}/docker/nocodb/data:/usr/app/data
    networks:
      - nocodb-network
    healthcheck:
      test: ['CMD-SHELL', 'wget -q --tries=1 --spider http://localhost:8080/api/v1/health || exit 1']
      interval: 30s
      timeout: 5s
      retries: 5
      start_period: 30s

  worker:
    image: nocodb/nocodb:latest
    container_name: nocodb-worker
    environment:
      NC_DB: 'pg://db:5432?u=nocodb&p={{postgres_password}}&d=nocodb'
      NC_REDIS_URL: 'redis://redis:6379'
      NC_SITE_URL: 'http://NAS-IP:8631'
      NC_AUTH_JWT_SECRET: '{{nc_auth_jwt_secret}}'
      NC_WORKER_CONTAINER: 'true'
    depends_on:
      nocodb:
        condition: service_healthy
    restart: unless-stopped
    volumes:
      - /{{volume}}/docker/nocodb/data:/usr/app/data
    networks:
      - nocodb-network

  db:
    image: postgres:17.10
    container_name: nocodb-db
    environment:
      POSTGRES_USER: nocodb
      POSTGRES_PASSWORD: {{postgres_password}}
      POSTGRES_DB: nocodb
    volumes:
      - /{{volume}}/docker/nocodb/db:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - nocodb-network
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U nocodb -d nocodb']
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7
    container_name: nocodb-redis
    volumes:
      - /{{volume}}/docker/nocodb/redis:/data
    restart: unless-stopped
    networks:
      - nocodb-network
    healthcheck:
      test: ['CMD', 'redis-cli', 'ping']
      interval: 10s
      timeout: 5s
      retries: 5

networks:
  nocodb-network:
    driver: bridge
```

Wichtige Details:

- **NC_DB-Format:** NocoDB erwartet das eigene Format `pg://HOST:PORT?u=USER&p=PASS&d=DBNAME`. Das übliche PostgreSQL-URL-Format (`postgresql://user:pass@host/db`) funktioniert nicht.
- **Gemeinsames Volume:** `nocodb` und `worker` müssen denselben Ordner auf `/usr/app/data` einbinden, damit der Worker auf hochgeladene Anhänge zugreifen kann.
- **PostgreSQL-Version:** Das offizielle Beispiel nutzt `postgres:17.10`, `postgres:17` zieht jeweils das neueste 17er-Release. Wechseln Sie nicht ohne Weiteres auf `postgres:18`: Ab Version 18 erwartet das Image sein Volume unter `/var/lib/postgresql`, und eine bestehende 17er-Datenbank muss migriert werden.
- **depends_on mit Healthcheck:** Ohne `condition: service_healthy` startet der Worker, bevor die API bereit ist, und startet ständig neu.
- **NC_SITE_URL:** Diese Adresse erscheint in E-Mail-Links und Webhooks. Nach Einrichtung eines Reverse Proxy tragen Sie hier die HTTPS-Adresse ein.

> Prüfen Sie nach dem Fertigstellen in Schritt 4 per SSH, ob die Compose-Datei am richtigen Ort liegt:
>
> ```bash
> grep "NC_DB" /{{volume}}/docker/nocodb/docker-compose.yml
> ```

Erwartet: zwei Zeilen mit `NC_DB: 'pg://db:5432?u=nocodb` (für nocodb und worker). Ohne Ausgabe liegt die Datei nicht im Projektordner.

## Schritt 4: Projekt starten und Container-Status prüfen

Klicken Sie zweimal auf *Weiter* und dann auf *Fertig*. Docker lädt zunächst die drei Images, je nach Verbindung dauert das 2 bis 5 Minuten. Das Terminal endet mit `Exit Code: 0`, in der Projektliste zeigt `nocodb` den grünen Status. Die Startreihenfolge regeln die Healthchecks:

1. `nocodb-db` (PostgreSQL) und `nocodb-redis` starten zuerst und parallel.
2. `nocodb` startet, sobald beide `(healthy)` melden.
3. `nocodb-worker` startet zuletzt, wenn `nocodb` den Health-Endpunkt beantwortet.

> Prüfen Sie per SSH den Status aller vier Container:
>
> ```bash
> sudo docker ps --filter "name=nocodb" --format "table {{.Names}}\t{{.Status}}"
> ```

Erwartete Ausgabe nach 60 bis 90 Sekunden:

```plaintext
NAMES             STATUS
nocodb-worker     Up X minutes
nocodb            Up X minutes (healthy)
nocodb-redis      Up X minutes (healthy)
nocodb-db         Up X minutes (healthy)
```

Zeigt ein Container dauerhaft „Restarting“, prüfen Sie die Logs mit `sudo docker logs nocodb`. Häufigste Ursache ist ein falsch formatierter `NC_DB`-String.

![Container Manager, Liste Projekt: grüner Status (1), Projekt nocodb (2), 4 Container (3)](https://s-edv.com/uploads/2026/10/030ef20ae882181ca6b7a5a038b5e354c47ae11ae17d0541bc77f6446f16170a-1024.png)
*Projekt läuft: 1 grüner Status, 2 Projekt nocodb, 3 4 Container.*

## Schritt 5: Erstanmeldung im Dashboard durchführen

Öffnen Sie im Browser (ist die DSM-Firewall aktiv, geben Sie vorher Port 8631 wie in Schritt 6 frei):

```plaintext
http://NAS-IP:8631/dashboard
```

Mit gesetzten Variablen `NC_ADMIN_EMAIL` und `NC_ADMIN_PASSWORD` erscheint die Anmeldemaske, sonst ein Registrierungsformular für den ersten Superadmin. Melden Sie sich mit den Zugangsdaten aus der Compose-Datei an, erstellen Sie eine neue **Basis** (entspricht einer Base in Airtable) und legen Sie eine Testtabelle an.

> **Prüfen:** Rufen Sie per SSH den Health-Endpunkt auf:
>
> ```bash
> curl -s http://localhost:8631/api/v1/health
> ```

Erwartet wird eine JSON-Antwort, die mit `{"message":"OK"` beginnt und zusätzlich `timestamp` und `uptime` enthält. Zusammen mit der sichtbaren Oberfläche ist der Stack betriebsbereit.

## Schritt 6: Firewall freischalten

Bei aktiver DSM-Firewall ist Port 8631 gesperrt. Geben Sie ihn unter **Systemsteuerung → Sicherheit → Firewall → Regeln bearbeiten** für Ihr lokales Subnetz frei. Details beschreibt [DSM-Firewall: Ports für Docker-Container freigeben](https://s-edv.com/anleitungen/synology-firewall-ports-freigeben-docker).

Für den Zugriff von außen öffnen Sie Port 8631 nicht direkt, sondern setzen einen Reverse Proxy ein (etwa den [Nginx Proxy Manager auf der Synology](https://s-edv.com/anleitungen/nginx-proxy-manager-synology-container-manager)), der HTTPS bereitstellt und nur Port 443 öffnet. Tragen Sie dann die HTTPS-Adresse in `NC_SITE_URL` ein. Aktivieren Sie im Proxy die WebSocket-Unterstützung (Header `Upgrade` und `Connection`), sonst aktualisieren sich geteilte Ansichten bei gleichzeitiger Bearbeitung nicht.

> **Prüfen:** Rufen Sie `http://NAS-IP:8631/dashboard` von einem anderen Gerät im Heimnetz auf. Erscheint die Anmeldemaske, ist die Firewall-Regel korrekt. Mit Reverse Proxy prüfen Sie zusätzlich die HTTPS-Adresse.

## Schritt 7: CSV-Import testen und API-Token erstellen

Zwei Funktionen sollten Sie direkt nach der Installation prüfen, beide hängen vom Worker und von Redis ab.

### CSV-Import über den Worker

Öffnen Sie eine Tabelle, klicken Sie auf das Pluszeichen neben dem letzten Reiter und wählen Sie **Import → CSV/Excel/JSON**. Laden Sie eine kleine CSV-Testdatei hoch. Der Worker verarbeitet den Import als Hintergrundjob, ein Fortschrittsbalken zeigt den Stand. 100 Zeilen sind in wenigen Sekunden importiert.

### API-Token erstellen

Öffnen Sie **Team & Einstellungen → API-Tokens → + Neues Token**, vergeben Sie einen sprechenden Namen (z. B. „Inventar-Integration“) und kopieren Sie das Token sofort, es wird nur einmal angezeigt. Die REST-API erreichen Sie anschließend unter `http://NAS-IP:8631/api/v2`. Die Swagger-Dokumentation einer Basis liegt unter `/api/v1/db/meta/projects/BASIS-ID/swagger`. Testen Sie das Token mit einem Aufruf, der Ihre Basen auflistet:

```bash
curl -s -H "xc-token: IHR_API_TOKEN" \
  http://localhost:8631/api/v2/meta/bases/
```

> **Prüfen:** Nach dem Import erscheinen alle Zeilen in der Tabelle, ohne Fehlermeldung. Der API-Aufruf liefert JSON mit einer Liste Ihrer Basen, nicht `Unauthorized`. Erscheint `Unauthorized`, wurde das Token unvollständig kopiert.

Grundlagen zum Betrieb finden Sie in [Docker Compose absichern: Secrets, Healthchecks, Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root) und [Linux-Server absichern mit UFW und Fail2ban](https://s-edv.com/anleitungen/linux-server-absichern-ufw-fail2ban).

## Troubleshooting / Typische Fehler

**„Invalid database url“ beim Start**

`NC_DB` steht im PostgreSQL-Standardformat. NocoDB erwartet `pg://HOST:PORT?u=USER&p=PASS&d=DBNAME`. Korrigieren Sie den Wert und erstellen Sie das Projekt neu.

**Worker startet ständig neu**

Redis ist nicht erreichbar oder `NC_REDIS_URL` fehlt. Prüfen Sie `sudo docker logs nocodb-worker` und ob `NC_REDIS_URL: 'redis://redis:6379'` gesetzt ist.

**Nutzer werden unerwartet abgemeldet**

Anmelde-Token laufen standardmäßig nach 10 Stunden ab (`NC_JWT_EXPIRES_IN`). Werden alle Nutzer nach einem Neustart abgemeldet, hat sich `NC_AUTH_JWT_SECRET` geändert. Setzen Sie wieder den ursprünglichen Wert.

**PostgreSQL startet nicht, „data directory has wrong ownership“**

Der Ordner hat falsche Rechte oder das Volume-Ziel stimmt nicht. Für `postgres:17` lautet es `/var/lib/postgresql/data`.

**PostgreSQL startet nach Wechsel auf `postgres:18` nicht**

Version 18 erwartet das Volume unter `/var/lib/postgresql` und kann 17er-Daten nicht direkt öffnen. Bleiben Sie bei `postgres:17` oder migrieren Sie per Dump und Restore.

**„502 Bad Gateway“ im Browser**

NocoDB ist noch nicht bereit. Warten Sie 60 bis 90 Sekunden und prüfen Sie mit `sudo docker ps`, ob `nocodb` `(healthy)` meldet.

**Einladungslinks zeigen „localhost“**

`NC_SITE_URL` fehlt oder zeigt auf `http://localhost:8080`. Tragen Sie die tatsächliche Adresse ein, z. B. `https://nas.beispiel.de`.

**CSV-Import hängt oder bricht ohne Meldung ab**

Redis oder der Worker laufen nicht. Prüfen Sie beide mit `sudo docker ps`.

## Häufige Fragen

### Kann ich eine bestehende PostgreSQL-Instanz mitnutzen?

Technisch ja: Zeigen Sie `NC_DB` auf den externen Container und stellen Sie sicher, dass beide im selben Docker-Netzwerk liegen. Für den Produktivbetrieb empfiehlt sich eine eigene Instanz, damit Updates und das in [PostgreSQL-Performance-Tuning für Einsteiger](https://s-edv.com/anleitungen/postgresql-performance-tuning-einsteiger) beschriebene Tuning keine anderen Anwendungen beeinflussen.

### Wie unterscheidet sich NocoDB von Metabase?

Metabase ist ein Werkzeug für Auswertung und Reporting: Dashboards, SQL-Abfragen, Diagramme. NocoDB dient der Erfassung und Pflege von Daten in einer Tabellenoberfläche. Beide ergänzen sich: Pflege in NocoDB, Auswertung in Metabase.

### Ist die Sustainable Use License wirklich „Open Source“?

Nein, nicht im Sinne der OSI. Die Sustainable Use License erlaubt die Nutzung für eigene interne Geschäftszwecke sowie für private und nicht kommerzielle Zwecke. Eine Weitergabe an andere ist nur unentgeltlich und nicht kommerziell erlaubt, ein Angebot als bezahlter Dienst für Dritte also nicht. Der interne Einsatz im eigenen Unternehmen auf eigenem NAS ist abgedeckt.

### Wie führe ich ein Update auf eine neue NocoDB-Version durch?

Sichern Sie zuerst den Ordner `/{{volume}}/docker/nocodb/db` bei gestopptem Projekt. Aktualisieren Sie dann im Container Manager die Images `nocodb/nocodb:latest` und `postgres:17.10` (oder `postgres:17`) und erstellen Sie das Projekt über *Aktion*, *Erstellen* neu. NocoDB führt Datenbankmigrationen beim Start automatisch aus.

Version 2026.10.0 führt laut Release Notes die bisherigen Interfaces als klassische Apps unter *Apps*; Seiten, Zugriffe und veröffentlichte Versionen bleiben erhalten. Neu sind unter anderem das Nachverfolgen vergangener Workflow-Läufe und die Formatierung von Textformeln als farbige Einfachauswahl. Im Test des Updates von 2026.09.1 auf 2026.10.0 am 26.10.2026 mit dieser Compose-Datei (Pfade lokal) waren `nocodb` und `worker` nach rund 20 Sekunden wieder bereit, `/api/v1/version` meldete 2026.10.0, die vorher angelegte Basis war vorhanden, die Anmeldung des Admins funktionierte, und ein falsches Passwort wurde mit `400` abgelehnt. Wer ein bestimmtes Release festhalten will, ersetzt `latest` bei `nocodb` und `worker` durch denselben Versions-Tag, etwa `nocodb/nocodb:2026.10.0`.

### Kann ich NocoDB mit Odoo verbinden?

Ja, über die REST-API von NocoDB oder über Webhooks, etwa wenn auf dem NAS auch [Odoo als ERP/CRM](https://s-edv.com/anleitungen/odoo-synology-erp-crm-kmu) läuft. Alternativ binden Sie die Odoo-Datenbank als externe Datenquelle in NocoDB ein.

### Was passiert mit den Daten, wenn ich den nocodb-Container neu erstelle?

Die Nutzdaten liegen in `/{{volume}}/docker/nocodb/data` (Anhänge) und `/{{volume}}/docker/nocodb/db` (PostgreSQL). Solange diese Ordner erhalten bleiben und `NC_AUTH_JWT_SECRET` unverändert ist, stehen nach dem Neuerstellen alle Tabellen und Datensätze sofort wieder bereit.

## Fazit

NocoDB ist eine aktiv gepflegte Airtable-Alternative, die sich auf dem Synology NAS mit vertretbarem Aufwand betreiben lässt. Mit PostgreSQL, Redis als Job-Queue und dem eigenen Worker ist der Stack für den Teambetrieb ausgelegt: CSV-Importe, Automationen und gleichzeitige Bearbeitung funktionieren zuverlässig. Die Daten bleiben auf eigener Hardware, ohne Abhängigkeit von einer US-Cloud.

## Weiterführende Anleitungen und Quellen

- [Container Manager auf dem Synology NAS: Docker-Compose-Projekt anlegen, starten und aktualisieren](https://s-edv.com/anleitungen/synology-container-manager-projekt-compose-anlegen)
- [DSM-Firewall auf dem Synology NAS: Ports für Docker-Container freigeben](https://s-edv.com/anleitungen/synology-firewall-ports-freigeben-docker)
- [Nginx Proxy Manager auf der Synology mit Container Manager einrichten: Reverse Proxy und SSL](https://s-edv.com/anleitungen/nginx-proxy-manager-synology-container-manager)
- [PostgreSQL-Performance-Tuning für Einsteiger](https://s-edv.com/anleitungen/postgresql-performance-tuning-einsteiger)
- [Odoo auf dem Synology NAS installieren: ERP und CRM für kleine Unternehmen](https://s-edv.com/anleitungen/odoo-synology-erp-crm-kmu)
- [Vaultwarden auf der Synology: eigener Passwortmanager mit Docker und SQLite-Backup](https://s-edv.com/anleitungen/vaultwarden-synology-passwortmanager-backup)

Offizielle Quellen: [NocoDB Self-Hosting Environment Variables](https://nocodb.com/docs/self-hosting/environment-variables) | [NocoDB Compose-Beispiele auf GitHub](https://github.com/nocodb/nocodb/tree/develop/docker-compose/examples) | [NocoDB GitHub Repository](https://github.com/nocodb/nocodb) | [NocoDB auf Docker Hub](https://hub.docker.com/r/nocodb/nocodb)