Kuonen SQL

Installation

Mit Docker in einer Minute, oder direkt auf dem Rechner als Dienst, der mit dem System startet: unter Linux mit systemd, unter macOS mit launchd, unter Windows als Windows-Dienst. Jeder Weg führt Schritt für Schritt hin, die Dienstdateien liegen fertig bereit.

Der schnellste Weg: ein fertiges Abbild für linux/amd64 und linux/arm64, signiert und mit Lizenzprüfung gebaut. Läuft überall, wo Docker läuft - auch auf macOS und Windows mit Docker Desktop.

  1. Abbild holen

    Die Marke latest zeigt auf die neueste Fassung; jede Fassung gibt es auch unter ihrer Nummer, etwa 1.12.427.

    bash
    docker pull kuomar/kuonensql:latest
  2. Starten

    Die Daten liegen im benannten Volume kuonensql-daten und überleben jeden neuen Container. Ein benanntes Volume statt eines Ordners: es gehört gleich dem Benutzer, unter dem der Server im Abbild läuft.

    bash
    docker run -d --name kuonensql --restart unless-stopped \
      -p 1433:1433 -p 6379:6379 \
      -e KUONENSQL_SA_PASSWORD='<Ihr-Kennwort>' \
      -v kuonensql-daten:/app/data \
      kuomar/kuonensql:latest
  3. Prüfen

    Nach wenigen Sekunden meldet das Protokoll „TDS-Server lauscht auf [::]:1433“.

    bash
    docker logs kuonensql
  4. Weitere Zugänge einschalten (wenn gewünscht)

    MySQL, MariaDB, PostgreSQL und GraphQL sind aus, bis ein Port gesetzt ist - dieselben Daten, nur eine andere Tür. Den Container dafür mit diesen Angaben zusätzlich neu anlegen:

    bash
    -p 3306:3306 -e KUONENSQL_MYSQL_PORT=3306 \
    -p 5432:5432 -e KUONENSQL_POSTGRESQL_PORT=5432
  5. Oder mit Compose

    compose.yaml in einen leeren Ordner legen. Ohne Kennwort in .env bricht der Aufruf ab, statt einen offenen Server zu starten.

    bash
    echo "KUONENSQL_SA_PASSWORD=<Ihr-Kennwort>" > .env
    docker compose up -d

Die Dateien

compose.yaml

Gehört nach ein leerer Ordner, daneben eine Datei .env. Im Quellstand: dist/dienst/docker/compose.yaml.

compose.yaml
# KuonenSQL mit Docker Compose, aus dem veröffentlichten Abbild (U19.10) - ohne Quellstand, ohne Bauen.
# In einen leeren Ordner legen, daneben eine Datei .env mit KUONENSQL_SA_PASSWORD=<Kennwort>, dann: docker compose up -d
# (docker/docker-compose.yml im Repo ist die Fassung für Entwickler: sie baut das Abbild aus dem Quellstand.)

services:
  kuonensql:
    image: kuomar/kuonensql:latest
    container_name: kuonensql
    restart: unless-stopped
    # Der Server schreibt beim Beenden einen Kontrollpunkt; so lange wartet Docker, bevor es hart beendet.
    stop_grace_period: 60s
    ports:
      - "1433:1433"   # T-SQL (SSMS, sqlcmd, EF Core)
      - "1333:1333"   # KSQL (TDS, der Kern mit ehrlicher Kennung)
      - "6379:6379"   # Redis
      - "3306:3306"   # MySQL 8.4
      - "5432:5432"   # PostgreSQL 17
    environment:
      # Ohne Kennwort bricht der Aufruf ab, statt einen offenen Server zu starten.
      KUONENSQL_SA_PASSWORD: ${KUONENSQL_SA_PASSWORD:?KUONENSQL_SA_PASSWORD in .env setzen}
      KUONENSQL_KSQL_PORT: "1333"
      KUONENSQL_MYSQL_PORT: "3306"
      KUONENSQL_POSTGRESQL_PORT: "5432"
      KUONENSQL_SORTIERUNG: ${KUONENSQL_SORTIERUNG:-SQL_Latin1_General_CP1_CI_AS}
    volumes:
      # Ein benanntes Volume statt eines Ordners: es gehört gleich dem Benutzer, unter dem der Server im Abbild läuft.
      - kuonensql-daten:/app/data

volumes:
  kuonensql-daten:

Im Betrieb

Protokoll laufend ansehen

bash
docker logs -f kuonensql

Stoppen und wieder starten

bash
docker stop kuonensql
docker start kuonensql

Auf die neueste Fassung

bash
docker pull kuomar/kuonensql:latest
docker rm -f kuonensql
docker run -d --name kuonensql --restart unless-stopped \
  -p 1433:1433 -p 6379:6379 \
  -e KUONENSQL_SA_PASSWORD='<Ihr-Kennwort>' \
  -v kuonensql-daten:/app/data \
  kuomar/kuonensql:latest

Auf die neueste Fassung (Compose)

bash
docker compose pull
docker compose up -d

Sicherung aus dem Container holen (nach BACKUP DATABASE … TO DISK = '/app/data/backup/…')

bash
docker cp kuonensql:/app/data/backup ./sicherung

Gut zu wissen

  • Docker wartet beim Stoppen 10 Sekunden, Compose 60 (stop_grace_period). In der Zeit schreibt der Server seinen Kontrollpunkt; ein hartes Ende kostet keine Daten, nur einen längeren nächsten Start.
  • Das Kennwort gilt ab dem ersten Start und bleibt als Hash im Volume. Später ändert es ALTER LOGIN sa WITH PASSWORD = '…'.

Verbinden

Mit SSMS: Servername localhost,1433, SQL Server-Authentifizierung, Anmeldung sa, unter „Verbindungssicherheit“ Serverzertifikat vertrauen. Aus einer Anwendung:

Verbindungszeichenfolge
Server=localhost,1433;User Id=sa;Password=<Ihr-Kennwort>;TrustServerCertificate=True

Alle Zugänge mit ihren Werkzeugen stehen unter Zugriff.

Anmelden beim ersten Start

Das Kennwort von sa setzt KUONENSQL_SA_PASSWORD beim Start — wie MSSQL_SA_PASSWORD bei SQL Server. Es bleibt als Hash im Datenordner. Ohne jedes Kennwort ist sa offen, und der Start warnt. Später ändert es:

T-SQL
ALTER LOGIN sa WITH PASSWORD = 'Ein-Starkes-Kennwort!2026';

Umgebungsvariablen

NameBedeutungVorgabe
KUONENSQL_DATEIFREIGABEWelche Ordner der Server nach außen zeigt (sys.dm_os_enumerate_filesystem/-file_exists, der Durchsuchen-Dialog von SSMS): Keine, Daten, Protokoll, Sicherung, Serverordner, Alles - mehrere mit Komma verbunden.Serverordner
KUONENSQL_SORTIERUNGDie Sortierung von master/tempdb und jeder neuen Datenbank ohne eigenes COLLATE. Jeder Name aus sys.fn_helpcollations(); ein unbekannter Name wird übergangen.SQL_Latin1_General_CP1_CI_AS
KUONENSQL_RESTZIELEDie Zielliste für den Ruf nach draußen (S12.5, z. B. externe KI-Modelle) - ohne sie geht kein Byte hinaus.leer
KUONENSQL_KSQL_PORTDer KSQL-Port: derselbe TDS-Draht, aber die Sitzung spricht den Kern ohne die Beschränkungen anderer Systeme und nennt die echte Fassung und das echte Wirtssystem. Ohne diese Variable bleibt er AUS; die Dienstvorlagen setzen 1333.aus
KUONENSQL_MARIADB_PORTDer MariaDB-Port. Ohne diese Variable (oder ein drittes Startargument) bleibt der MariaDB-Draht AUS - eine zweite Tür geht nur auf, wer sie will.aus
KUONENSQL_GRAPHQL_PORTDer HTTP-Port für GraphQL (/graphql) und SPARQL (/sparql). Ohne ihn (oder ein viertes Startargument) bleiben beide AUS; angemeldet wird nur mit Kennwort.aus
KUONENSQL_MARIADB_ANMELDUNGDas MariaDB-Anmeldeverfahren (mysql_native_password, caching_sha2_password, client_ed25519).—
KUONENSQL_TLS_CERT_PATHPfad zu einem PFX-Serverzertifikat. Ohne Angabe erzeugt der Server beim ersten Verbindungsaufbau - wie SQL Server - ein selbstsigniertes Zertifikat (CN=KuonenSQL).—
KUONENSQL_TLS_CERT_PASSWORDDas Kennwort des PFX-Zertifikats.—
KUONENSQL_FORCE_ENCRYPTIONVerschlüsselung erzwingen - auch ein Client mit Encrypt=False bekommt dann die volle Verbindung verschlüsselt.false
KUONENSQL_VERSIONSTEXTErsetzt den Text von @@VERSION am T-SQL-Zugang, etwa durch "Kuonen SQL Server 2026 17.0". Die Produktversion bleibt 17.0; ob ein Werkzeug den Text liest, zeigt nur der Versuch.Ansage als SQL Server 2025
KUONENSQL_TLS_DISABLEDKeine Verschlüsselung anbieten; ein Client mit Encrypt=True wird abgewiesen.false
KUONENSQL_DATEN_PFADDer persistente Datenpfad auf dem Host (Bind-Mount nach /app/data)../Daten/kuonensql
KUONENSQL_PORTDer TDS-Port des Containers nach außen.1433
KUONENSQL_REDIS_PORTDer Redis-Port des Containers nach außen.6379

Verschlüsselung (TLS)

Ohne eigenes Zertifikat erzeugt der Server beim ersten Verbindungsaufbau — wie SQL Server — ein selbstsigniertes Zertifikat (CN=KuonenSQL). Clients brauchen dann TrustServerCertificate=True (in SSMS: „Serverzertifikat vertrauen“). Ein eigenes PFX-Zertifikat binden KUONENSQL_TLS_CERT_PATH und KUONENSQL_TLS_CERT_PASSWORD ein.

Lizenz

Das Docker-Abbild ist der geschützte Auslieferungsbau (dist/build-protected.sh): signiert, verschleiert und mit Lizenzprüfung vor dem Start. Der gewöhnliche Entwicklungsbau — auch die selbst gebaute Einzeldatei — prüft keine Lizenz.

Für Entwickler: aus dem Quellstand

Das Abbild selbst bauen: Die Befehle laufen im Ordner KuonenSQL des Repos Kuonen, der Bau-Kontext ist dessen Wurzel; docker-compose.yml, .env.beispiel und das mehrstufige Dockerfile liegen unter KuonenSQL/docker/ (siehe KuonenSQL/docker/README.md).

ZweckBefehl
Bauen und im Hintergrund startendocker-compose --project-directory . --env-file docker/.env -f docker/docker-compose.yml up -d --build
Protokolle ansehendocker-compose --project-directory . --env-file docker/.env -f docker/docker-compose.yml logs -f
Stoppendocker-compose --project-directory . --env-file docker/.env -f docker/docker-compose.yml down
Veröffentlichtes Abbild ziehen, statt selbst zu bauendocker pull kuomar/kuonensql:latest
Ohne Compose, mit den Vorgabeports 1433/6379docker run -d --name kuonensql-server -p 1433:1433 -p 6379:6379 -e KUONENSQL_SORTIERUNG=SQL_Latin1_General_CP1_CI_AS -v kuonensql-daten:/app/data kuomar/kuonensql:latest
Bauen (Windows x64, Vorgabe)powershell -ExecutionPolicy Bypass -File dist\einzeldatei-bauen.ps1
Bauen für eine andere Plattformpowershell -ExecutionPolicy Bypass -File dist\einzeldatei-bauen.ps1 -Plattform linux-x64
StartenKuonen.Data.KuonenSql.Server 1433 6379

Die Einzeldatei bringt die .NET-Laufzeit mit, verzichtet aber noch nicht auf den JIT (Native AOT, Roadmap L6.3). Für macOS ist sie unkomprimiert: Unter .NET 10.0.6 stürzt eine komprimierte Einzeldatei dort beim Annehmen von Verbindungen ab.