---
title: "SQLite auf der Netzfreigabe: Was über SMB kaputtgeht"
date: 2026-11-15T19:01:06+01:00
modified: 2026-11-15T19:12:55+01:00
category: datenbanken
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/ernstfall-sqlite-netzfreigabe-smb-nobrl
keywords:
  - Ernstfall
  - SQLite
  - SMB
  - Samba
  - CIFS
  - NAS
  - Datenverlust
  - Docker
reading_time: 8
ai_notice: "Mit KI erstellt – redaktionelle Prüfung ausstehend"
---

# SQLite auf der Netzfreigabe: Was über SMB kaputtgeht

> Mit KI erstellt – redaktionelle Prüfung ausstehend ([KI-Transparenz](https://s-edv.com/ki-transparenz))

Die Datenbank eines Dienstes liegt auf einem NAS, eingebunden per SMB. Das spart lokalen Platz und landet gleich in der Sicherung des NAS. Die SQLite-Entwickler raten davon ab. Für diese Anleitung wurde nachgestellt, was dann passiert: SQLite auf einer Samba-Freigabe, mit Standard-Einbindung und mit der Mount-Option `nobrl`, mit einem und mit zwei Schreibern, jeder Fall dreimal.

**Dies ist Teil 12 der Reihe „Ernstfall“.** Jeder Teil macht absichtlich etwas kaputt, misst, was passiert, und zeigt den Weg zurück.

**Kurzfassung:** Mit der Standard-Einbindung scheiterte auf der Freigabe schon das Anlegen der Datenbank mit `database is locked`, und eine dorthin kopierte Datenbank nahm keine einzige Buchung an. Mit `nobrl` verschwand die Meldung, und ein einzelner Schreiber arbeitete fehlerfrei. Schrieben zwei Clients gleichzeitig, war die Datenbank in allen sechs Durchgängen danach falsch: Kontensummen stimmten nicht, bestätigte Buchungen fehlten, zweimal war die Datei beschädigt, zweimal ließ sie sich direkt danach nicht öffnen. Lokal blieben dieselben Abläufe in jedem Durchgang korrekt.

## Was Sie brauchen

- [ ] Einen Linux-Server mit Docker, siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Einen Dienst mit SQLite-Datenbank, dessen Datenordner auf einer Netzfreigabe liegen könnte.
- [ ] Das Programm `sqlite3` für die Prüfung.

## Schritt 1: Prüfen, wo die Datenbank liegt

Schauen Sie nach, welche Ordner per SMB eingebunden sind, und vergleichen Sie das mit den Datenordnern Ihrer Dienste:

```bash
$ mount | grep cifs
```

Ausgabe:

```plaintext
//samba/daten on /mnt/smb type cifs (rw,relatime,vers=3.1.1,cache=strict,...)
```

Liegt der Ordner eines Dienstes mit SQLite-Datenbank unter einem dieser Pfade, betrifft Sie diese Anleitung. Wurde die Freigabe mit der Option `nobrl` eingebunden, ist die Lage ernster, siehe Ergebnis 2.

> **Prüfen:** **Verifizieren:** Sie kennen für jeden Dienst mit SQLite den Ort der Datenbankdatei und wissen, ob er auf einer lokalen Platte oder einer Freigabe liegt.

## Schritt 2: Datenbank auf eine lokale Platte legen

Legen Sie den Datenordner des Dienstes auf eine lokale Platte des Servers, in Docker Compose als Ordner neben der Compose-Datei:

Datei: `compose.yaml`

```yaml
services:
  app:
    volumes:
      - ./daten:/data
```

Stoppen Sie den Dienst vorher mit `docker compose stop`, damit beim Umziehen niemand in die Datei schreibt. Die Sicherung auf das NAS übernimmt dann ein Backup-Programm, nicht die Freigabe selbst, siehe [Teil 1 der Reihe](https://s-edv.com/anleitungen/ernstfall-datenbank-live-kopiert-backup-kaputt) zum sicheren Kopieren einer laufenden Datenbank.

> **Prüfen:** **Verifizieren:** `mount | grep cifs` zeigt keinen Pfad mehr, unter dem der Datenordner liegt, und der Dienst startet mit seinen Daten.

## Schritt 3: Datenbank nach einem Vorfall prüfen

Lief eine SQLite-Datenbank schon auf einer Freigabe, prüfen Sie sie mit der eingebauten Prüfung. Eine heile Datei liefert genau ein `ok`, eine beschädigte eine Liste von Fehlern wie diese aus dem Test:

```bash
$ sqlite3 /pfad/zur/datenbank.db "PRAGMA integrity_check"
```

Ausgabe:

```plaintext
*** in database main ***
Tree 2 page 2 cell 1: Rowid 829 out of order
```

Verlassen Sie sich nicht allein darauf. Im Test meldete die Prüfung zweimal `ok`, obwohl die Kontensumme nicht stimmte und mehr Buchungen in der Datei standen als bestätigt. Prüfen Sie zusätzlich, was die Anwendung selbst prüfen kann, etwa Summen oder Zählerstände, oder spielen Sie die letzte Sicherung von vor dem Umzug auf die Freigabe zurück.

> **Prüfen:** **Verifizieren:** Die Prüfung meldet `ok`, und die Daten der Anwendung sind in sich stimmig.

## So wurde gemessen

Ein eigener Testserver mit Linux-Kernel 6.8 und Docker 29.9.3 stellte mit Samba 4.23.8 eine Freigabe bereit. Zwei weitere Container auf demselben Server banden die Freigabe jeweils selbst mit `mount -t cifs` und SMB 3.1.1 ein, einmal mit Standardoptionen, einmal zusätzlich mit `nobrl`. Darin lief SQLite 3.53.4, im Modus mit Rollback-Journal und im Modus WAL. Zum Vergleich lag dieselbe Datenbank auf der lokalen Platte des Servers.

Die Einbindung in jedem Client sah so aus, für die zweite Variante mit angehängtem `,nobrl`. Die Container liefen dafür mit erweiterten Rechten (`privileged: true`), damit sie selbst einbinden konnten:

```bash
$ mount -t cifs //samba/daten /mnt/smb -o username=probe,password=IHR_PASSWORT,vers=3.1.1
```

Die Datenbank enthielt 1.000 Konten mit je 1.000 Einheiten. 60 Sekunden lang buchten die Clients Überweisungen: einem Konto eine Einheit abziehen, einem anderen gutschreiben, eine Buchungszeile anlegen, alles in einer Transaktion. Jede bestätigte Transaktion wurde notiert. Am Ende musste die Summe aller Konten genau 1.000.000 sein und die Zahl der Buchungen der Zahl der Bestätigungen entsprechen.

Datei: `bank.sh, gekürzt`

```bash
sqlite3 -cmd ".timeout 5000" "$db" "BEGIN IMMEDIATE;
  UPDATE konto SET saldo=saldo-1 WHERE id=$a;
  UPDATE konto SET saldo=saldo+1 WHERE id=$b;
  INSERT INTO buchung(von,nach,wer) VALUES($a,$b,'$n');
  COMMIT;"
```

## Ergebnis 1: Standard-Einbindung verweigert das Schreiben

![Diagramm: SQLite auf einer SMB-Freigabe, acht Varianten in je drei Durchgängen, lokal und mit einem Schreiber korrekt, Standard-Einbindung mit database is locked, zwei Schreiber mit nobrl immer falsch](https://s-edv.com/uploads/2026/11/44d1775f93ac055262f3d29faccb57a029710c20702b3260bf68ad8db9609fc0-1024.png)
*Acht Varianten in je drei Durchgängen: lokal immer korrekt, SMB Standard verweigert, nobrl mit einem Schreiber korrekt, mit zwei Schreibern immer falsch*

Mit der Standard-Einbindung legte `sqlite3` auf der Freigabe zwar eine Datei an, sie blieb aber 0 Byte groß. Schon das Anlegen der ersten Tabelle scheiterte:

Ausgabe:

```plaintext
Error in 2nd command line argument: database is locked
```

Damit kam auch der Versuch mit zwei Schreibern auf der Standard-Einbindung nie über das Anlegen hinaus. Auch eine Datenbank, die lokal angelegt und auf die Freigabe kopiert wurde, nahm keine einzige Buchung an. Jeder Versuch wartete die eingestellten fünf Sekunden und endete mit derselben Meldung. Das ist ärgerlich, aber sicher: Es entstehen keine falschen Daten. Es hängt an den Sperren, die SQLite für jede Transaktion setzt: Mit der Mount-Option `nobrl`, die keine Sperren an den Server schickt, verschwand die Meldung sofort. Laut Handbuchseite von mount.cifs brauchen manche Anwendungen diese Option, weil sie mit den Sperren von CIFS nicht zurechtkommen.

Lokal liefen dieselben Abläufe ohne einen Fehler. Die beiden Clients schafften zusammen 10.458 bis 12.755 Buchungen im Modus mit Rollback-Journal und 11.661 bis 12.402 im Modus WAL, die Summe stimmte jedes Mal.

## Ergebnis 2: nobrl beseitigt die Meldung, nicht das Problem

Die Mount-Option `nobrl` schickt keine Sperren mehr an den Server. Die Meldung `database is locked` verschwand damit. Ein einzelner Schreiber arbeitete fehlerfrei: 3.563 bis 3.653 Buchungen mit Rollback-Journal, 1.948 bis 2.105 mit WAL, Summe und Buchungen stimmten in allen Durchgängen.

![Diagramm: zwei Schreiber mit nobrl, bestätigte Buchungen gegen Buchungen in der Datei und Kontensummen je Durchgang](https://s-edv.com/uploads/2026/11/ef285bba5c6697e3ea3137658c0cfc6d7a3de64516d194e0f240826be186d3f1-1024.png)
*Zwei Schreiber über nobrl: bestätigte Buchungen gegen Buchungen in der Datei, Kontensummen falsch oder Datei unlesbar*

Mit zwei Clients ging jeder der sechs Durchgänge schief. Ohne Sperren hält nichts mehr die beiden davon ab, gleichzeitig in dieselbe Datei zu schreiben. Im Modus mit Rollback-Journal stimmte die Kontensumme einmal um 7 Einheiten nicht, einmal um eine, und es standen mehr Buchungen in der Datei als bestätigt. Die eingebaute Prüfung meldete in beiden Fällen trotzdem `ok`. Im Modus WAL fehlten bestätigte Buchungen, und die Kontensumme lag um Zehntausende daneben (928.769 und 911.837 statt 1.000.000): 1.006 bestätigt, 997 in der Datei, im nächsten Durchgang 277 gegen 250. Die Prüfung fand beide Male eine beschädigte Datei. In einem Durchgang je Modus ließ sich die Datei direkt danach nicht mehr öffnen:

Ausgabe:

```plaintext
Parse error in 4th command line argument: unable to open database file (14)
```

Während der Läufe meldeten die Clients außerdem `disk I/O error`, `locking protocol` und `cannot commit - no transaction is active`. Wer solche Meldungen in den Logs eines Dienstes sieht, dessen Datenbank auf einer Freigabe liegt, sollte die Datei sofort prüfen.

## Was das für Ihren Server heißt

SQLite gehört auf eine lokale Platte. Die SQLite-Entwickler raten in ihrer Dokumentation selbst von Netzdateisystemen ab und begründen es unter anderem mit Sperren, die dort nicht zuverlässig funktionieren. Für viele Schreiber über das Netz empfehlen sie eine Datenbank mit eigenem Server. Wer die Meldung `database is locked` mit `nobrl` wegkonfiguriert, tauscht einen sichtbaren Fehler gegen einen unsichtbaren, sobald ein zweiter Rechner oder Container mit eigener Einbindung in dieselbe Datei schreibt.

Braucht ein Dienst mehrere Schreiber über das Netz, ist eine Datenbank mit eigenem Server die richtige Wahl, viele Dienste bieten dafür PostgreSQL oder MariaDB an. Für die Sicherung auf das NAS sorgt ein Backup-Programm.

## Typische Fehler

**`database is locked` bei jedem Schreibversuch**

Die Datei liegt vermutlich auf einer SMB-Freigabe. Prüfen Sie das wie in Schritt 1 und legen Sie die Datenbank lokal ab wie in Schritt 2. Nicht `nobrl` setzen.

**`no such table` direkt nach dem Anlegen**

Im Test eine Folge davon, dass schon das Anlegen der Tabelle mit `database is locked` scheiterte. Die Datei existiert, ist aber leer.

**`unable to open database file (14)` oder `disk I/O error`**

Im Test Folgen gleichzeitiger Zugriffe über `nobrl`. Dienst stoppen, Datei prüfen wie in Schritt 3.

## Häufige Fragen

### Ist WAL auf einer Freigabe besser als das Rollback-Journal?

Nein. Mit einem Schreiber arbeiteten beide fehlerfrei, mit zwei Schreibern scheiterten beide, WAL im Test sogar mit fehlenden bestätigten Buchungen und beschädigten Dateien.

### Reicht es, nur einen Schreiber zuzulassen?

Im Test lief ein einzelner Schreiber mit `nobrl` in allen Durchgängen korrekt. Die Sicherheit hängt dann aber allein daran, dass nie ein zweiter Container oder Rechner mit eigener Einbindung in dieselbe Datei schreibt. Die lokale Platte verlangt diese Disziplin nicht.

## Fazit

SQLite auf einer SMB-Freigabe scheitert entweder laut oder leise. Laut mit der Standard-Einbindung: `database is locked`, aber keine falschen Daten. Leise mit `nobrl`: Solange einer schreibt, geht es gut, sobald zwei schreiben, stimmen Summen nicht mehr, Buchungen fehlen, Dateien lassen sich nicht mehr öffnen. Die Lösung ist in beiden Fällen dieselbe, die Datenbank gehört auf die lokale Platte. Im nächsten und letzten Teil der Reihe wird ein Dienst mitten im Schreiben hart beendet.

## Weiterführende Anleitungen und Quellen

- [Ernstfall Teil 1: Datenbank im laufenden Betrieb kopiert](https://s-edv.com/anleitungen/ernstfall-datenbank-live-kopiert-backup-kaputt)
- [Ernstfall Teil 2: Platte voll](https://s-edv.com/anleitungen/ernstfall-platte-voll-docker-dienste-datenbanken)
- [Ernstfall Teil 3: Update zurückdrehen](https://s-edv.com/anleitungen/ernstfall-update-zurueckdrehen-downgrade-docker)
- [Ernstfall Teil 4: PostgreSQL 16 auf 18 per Tag](https://s-edv.com/anleitungen/ernstfall-postgresql-16-auf-18-tag-upgrade)
- [Ernstfall Teil 5: Container-Logs fluten die Platte](https://s-edv.com/anleitungen/ernstfall-docker-logs-platte-voll-max-size)
- [Ernstfall Teil 6: down -v, prune, rm](https://s-edv.com/anleitungen/ernstfall-docker-volumes-geloescht-down-v-prune)
- [Ernstfall Teil 7: Angreifer kennt das Backup-Passwort](https://s-edv.com/anleitungen/ernstfall-ransomware-restic-append-only-angriff)
- [Ernstfall Teil 8: Restore-Rennen](https://s-edv.com/anleitungen/ernstfall-restore-rennen-restic-borgbackup-kopia)
- [Ernstfall Teil 9: Registry weg, Internet weg](https://s-edv.com/anleitungen/ernstfall-docker-registry-internet-weg-offline-start)
- [Ernstfall Teil 10: Admin-Passwort weg](https://s-edv.com/anleitungen/ernstfall-admin-passwort-vergessen-zuruecksetzen-docker)
- [Ernstfall Teil 11: Zertifikat abgelaufen, Uhr falsch](https://s-edv.com/anleitungen/ernstfall-zertifikat-abgelaufen-uhr-falsch)
- [Ernstfall Teil 13: Harter Abbruch](https://s-edv.com/anleitungen/ernstfall-harter-abbruch-kill-datenbank-redis)
- [UGREEN NAS per SMB unter Windows einbinden](https://s-edv.com/anleitungen/ugreen-nas-smb-windows-netzlaufwerk)
- [Vaultwarden auf der Synology mit SQLite-Backup](https://s-edv.com/anleitungen/vaultwarden-synology-passwortmanager-backup)
- [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
- [SQLite: SQLite Over a Network](https://www.sqlite.org/useovernet.html)
- [SQLite: PRAGMA integrity_check](https://www.sqlite.org/pragma.html#pragma_integrity_check)
- [mount.cifs (cifs-utils)](https://man7.org/linux/man-pages/man8/mount.cifs.8.html)
