Eine KOSTENLOSE und Open Source Airtable Alternative - Wie du NocoDB mit Docker startest

NocoDB ist eine Open Source Airtable Alternative. Auf ihrer Website behaupten sie, dass es "das Erstellen von No-Code-Datenbanklösungen mit der Einfachheit von Spreadsheets ermöglicht." Du kannst jede Datenbank in eine intelligente Spreadsheet-Oberfläche verwandeln, Formulare erstellen, APIs entwickeln und mit deinem Team zusammenarbeiten.

In dieser Anleitung möchte ich dir zeigen, wie einfach es ist, deine eigene Instanz dieses kostenlosen Datenbank-Management-Tools in der Cloud mit Docker und Sliplane zu starten.

Lokale Tests

Du kannst das Setup lokal auf deinem Computer testen. Stelle nur sicher, dass Docker Desktop auf deinem Rechner installiert ist und läuft. Es ist jedoch noch einfacher, wenn du es direkt in Sliplane machst, was ich im nächsten Abschnitt beschreiben werde.

Mit SQLite

Öffne ein Terminal und führe aus:

docker run -d --name nocodb \
    -v "$(pwd)"/nocodb:/usr/app/data/ \
    -p 8080:8080 \
    nocodb/nocodb:0.263.8

Was hier passiert:

• Wir verwenden docker run, um einen neuen Container zu starten
• Wir nennen ihn nocodb, du kannst einen anderen Namen wählen
• Wir mounten ein neues Volume zu /usr/app/data, das bedeutet, alles was nocodb in diesem Verzeichnis speichert, wird außerhalb des Containers gespeichert und bleibt bestehen, auch wenn der Container irgendwann heruntergefahren oder zerstört wird. NocoDB wird unsere SQLite-Datenbankdatei hier erstellen
• Wir mappen Port 8080 innerhalb des Containers auf 8080 auf unserem Host
• Wir spezifizieren das Image, das ausgeführt werden soll: nocodb/nocodb zusammen mit der Version des Images (hier: 0.263.8, aber du kannst eine andere Version verwenden, falls nötig)

Du kannst testen, ob die App läuft, indem du in deinem Webbrowser zu http://localhost:8080 navigierst. Dokumentation darüber, wie du NocoDB konfigurieren kannst, findest du auf Dockerhub.

Login-Bildschirm nach der ersten Installation.

Mit PostgreSQL

Wenn du PostgreSQL als zugrunde liegende Datenbank verwenden möchtest, musst du zuerst einen PostgreSQL Container starten:

1. Erstelle ein neues Netzwerk

docker network create nocodb-net

Starte einen PostgreSQL Container mit dem folgenden Befehl:

docker run --name nocodb-postgres \
  -e POSTGRES_PASSWORD=mysecretpassword \
  -e POSTGRES_DATABASE=nocodb \
  -v "$(pwd)"/postgres:/var/lib/postgresql/data \
  --network nocodb-net \
  -d postgres:17.2

Was hier passiert:

• Wir verwenden docker run, um einen neuen Container zu starten
• Wir nennen ihn nocodb-postgres, du kannst einen anderen Namen wählen
• Wir setzen die Datenbank und ein Passwort mit den -e Umgebungsvariablen
• Wir mounten ein neues Volume zu /var/lib/postgresql/data, das bedeutet, alles was PostgreSQL in diesem Verzeichnis speichert, wird außerhalb des Containers gespeichert und bleibt bestehen, auch wenn der Container irgendwann heruntergefahren oder zerstört wird. Hinweis: PostgreSQL hat diesen Mount-Pfad nach Version 18 geändert - bitte beziehe dich immer auf die Dokumentation, je nachdem welche Version du verwendest
• Wir spezifizieren das Image, das ausgeführt werden soll: postgres zusammen mit der Version des Images

In diesem Fall habe ich 17.2 als Version verwendet. Stelle sicher, dass du die PostgreSQL-Dokumentation auf Docker Hub überprüfst, um Konfigurationen zu finden, die zur PostgreSQL-Version passen, die du verwendest.

Als nächstes starte den NocoDB Container und verbinde ihn mit der PostgreSQL-Datenbank:

docker run -d --name nocodb \
  -v "$(pwd)"/nocodb:/usr/app/data/ \
  -p 8080:8080 \
  --network nocodb-net \
  -e NC_DB="pg://nocodb-postgres:5432?u=postgres&p=mysecretpassword&d=nocodb" \
  -e NC_AUTH_JWT_SECRET="your-jwt-auth-secret" \
  nocodb/nocodb:0.263.8

Was hier passiert:

• Wir verwenden docker run, um einen neuen Container zu starten
• Wir nennen ihn nocodb, du kannst einen anderen Namen wählen
• Wir mounten ein Volume -v zu /usr/app/data/
• Wir setzen ein JWT-Auth-Secret und die Datenbank-URI, um uns mit unserer PostgreSQL-Datenbank mit dem Postgres-Benutzer und Passwort zu verbinden
• Wir spezifizieren das Image, das ausgeführt werden soll: nocodb/nocodb zusammen mit der Version des Images (0.263.8)

Du kannst jetzt auf NocoDB unter http://localhost:8080 auf deinem eigenen Host zugreifen.

Mit Docker Compose

Du kannst auch Docker Compose verwenden. Erstelle eine Datei namens docker-compose.yml:

services:
  postgres:
    image: postgres:17.2
    container_name: nocodb-postgres
    environment:
      POSTGRES_DB: nocodb
      POSTGRES_PASSWORD: mysecretpassword
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - nocodb-net
    restart: unless-stopped

  nocodb:
    image: nocodb/nocodb:0.263.8
    container_name: nocodb
    depends_on:
      - postgres
    environment:
      NC_DB: "pg://postgres:5432?u=postgres&p=mysecretpassword&d=nocodb"
      NC_AUTH_JWT_SECRET: "your-jwt-auth-secret"
    ports:
      - "8080:8080"
    volumes:
      - nocodb_data:/usr/app/data
    networks:
      - nocodb-net
    restart: unless-stopped

volumes:
  postgres_data:
  nocodb_data:

networks:
  nocodb-net:

Dann führe einfach aus:

docker-compose up -d

In der Cloud ausführen:

Wir verwenden Sliplane, um es in der Cloud auszuführen. Sliplane macht das Ausführen von Containern in der Cloud sehr einfach und erschwinglich.

Im Allgemeinen folgen wir einfach den Schritten wie bei unserem lokalen Setup, aber mit ein paar einfachen Änderungen - tatsächlich ist es auf Sliplane sogar noch einfacher.

1. Eine PostgreSQL-Datenbank bereitstellen

Hinweis: Wenn du SQLite verwenden möchtest, kannst du diesen Teil überspringen und mit Schritt 2 fortfahren

1. Melde dich bei Sliplane mit deinem GitHub-Account an. Klicke im Dashboard auf "Create Project" und nenne es "nocodb".
2. Klicke auf "Deploy Service".
3. Wähle einen Server aus oder erstelle einen neuen, falls du noch keinen hast. Um einen neuen zu erstellen, klicke auf "Create Server", dann wähle den Standort und Servertyp. Der Base-Servertyp sollte ausreichen, um anzufangen, du kannst später hochskalieren, falls nötig.
4. Wähle PostgreSQL aus den Presets. Deaktiviere in den Einstellungen den Public-Toggle für zusätzliche Sicherheit. Du kannst auch den Standard-Datenbanknamen, Benutzer und Passwort ändern, wenn du möchtest. Dann klicke auf Deploy und warte, bis deine Datenbank bereitgestellt ist.

2. NocoDB bereitstellen

1. Klicke im Projekt, das wir in Schritt 1 erstellt haben, erneut auf "Deploy Service".
2. Wähle den Server, auf dem PostgreSQL läuft, und wähle im Abschnitt "Deploy From" die Option "Registry".
3. Suche im Feld "Image URL" nach nocodb und wähle das nocodb/nocodb Image und einen Tag aus der Liste.
4. Füge die folgenden Umgebungsvariablen hinzu, aber stelle sicher, dass du das Passwort, die Datenbank und den internen Host änderst, um den Einstellungen deiner PostgreSQL-Datenbank zu entsprechen. Ich empfehle dir, einen neuen Tab mit dem PostgreSQL-Service auf Sliplane zu öffnen, um diese Werte von dort zu holen:

NC_DB="pg://[postgres.internal]:5432?u=postgres&p=[password]&d=[database]"
NC_AUTH_JWT_SECRET="your-secure-jwt-secret"

5. Füge ein Volume zu deinem NocoDB-Service hinzu, gib ihm einen Namen deiner Wahl und setze den Mount-Pfad auf /usr/app/data
6. Klicke auf "Deploy" und warte, bis das Deployment abgeschlossen ist.

Du kannst jetzt über deine ...sliplane.app Domain, die im Dashboard angezeigt wird, auf NocoDB zugreifen!

Zusammenfassung

NocoDB ist eine solide kostenlose Alternative zu Airtable (obwohl Airtable jetzt mehr Produktangebote über das Verwandeln von Datenbanken in Spreadsheets hinaus hat). Durch Self-Hosting bekommst du deine eigenen Daten und Kontrolle und so ziemlich die gleiche Funktionalität zu einem Bruchteil der Kosten im Vergleich zu kommerziellen SaaS-Optionen.

Das Setup mit Docker auf Sliplane ist in wenigen Minuten möglich.