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 Server als Einzeldatei, als echter Windows-Dienst eingetragen: startet mit Windows, ohne Anmeldung, nach einem Absturz neu, und erscheint in der Dienstverwaltung. Die Anbindung an die Dienstverwaltung übernimmt WinSW, ein kleines freies Werkzeug (MIT-Lizenz).

  1. Die Einzeldatei

    Aus der Auslieferung (win-x64 oder win-arm64) - oder aus dem Quellstand gebaut, mit dem .NET 10 SDK und PowerShell 7. Die .NET-Laufzeit ist darin enthalten, auf dem Zielrechner muss nichts installiert sein. Die folgenden Schritte laufen im Ordner mit der Einzeldatei und den Dateien unten.

    PowerShell
    powershell -ExecutionPolicy Bypass -File dist\einzeldatei-bauen.ps1
    cd einzeldatei\win-x64
  2. Programm, Dienstdatei und WinSW

    Im Ordner mit der Einzeldatei und KuonenSQL-Dienst.xml. WinSW heisst danach wie seine Konfiguration - so findet es sie.

    PowerShell
    $ziel = "$env:ProgramFiles\KuonenSQL"
    New-Item -ItemType Directory -Force $ziel, "$env:ProgramData\KuonenSQL\Daten" | Out-Null
    Copy-Item .\Kuonen.Data.KuonenSql.Server.exe, .\KuonenSQL-Dienst.xml $ziel
    Invoke-WebRequest https://github.com/winsw/winsw/releases/download/v2.12.0/WinSW-x64.exe -OutFile "$ziel\KuonenSQL-Dienst.exe"
  3. Kennwort eintragen

    Unter KUONENSQL_SA_PASSWORD, wenn gewünscht weitere Ports.

    PowerShell
    notepad "$env:ProgramFiles\KuonenSQL\KuonenSQL-Dienst.xml"
  4. Dienst einrichten und starten

    Startet ab jetzt mit Windows (verzögert, nach dem Netz).

    PowerShell
    & "$env:ProgramFiles\KuonenSQL\KuonenSQL-Dienst.exe" install
    Start-Service KuonenSQL
  5. Prüfen

    Status „Running“ und im Protokoll „TDS-Server lauscht auf [::]:1433“.

    PowerShell
    Get-Service KuonenSQL
    Get-Content "$env:ProgramData\KuonenSQL\Protokoll\KuonenSQL-Dienst.out.log" -Tail 20
  6. Firewall öffnen (wenn andere Rechner zugreifen)

    Nur die Ports, die gebraucht werden.

    PowerShell
    New-NetFirewallRule -DisplayName "KuonenSQL (T-SQL)" -Direction Inbound -Protocol TCP -LocalPort 1433 -Action Allow

Die Dateien

KuonenSQL-Dienst.xml

Gehört nach C:\Program Files\KuonenSQL\KuonenSQL-Dienst.xml. Im Quellstand: dist/dienst/windows/KuonenSQL-Dienst.xml.

KuonenSQL-Dienst.xml
<!--
  KuonenSQL als Windows-Dienst über WinSW 2.12 (MIT-Lizenz, https://github.com/winsw/winsw) (U19.10).
  Ablage: C:\Program Files\KuonenSQL\KuonenSQL-Dienst.xml, neben WinSW-x64.exe, umbenannt in KuonenSQL-Dienst.exe, und dem Server.
  Die Schritte stehen im Prüfstand unter Installation → Windows. Der Server selbst spricht nicht mit der Dienstverwaltung von
  Windows; WinSW tut das für ihn und beendet ihn mit Strg+C, worauf er seinen Kontrollpunkt schreibt.
-->
<service>
  <id>KuonenSQL</id>
  <name>KuonenSQL</name>
  <description>KuonenSQL Datenbankserver (KSQL, T-SQL, MySQL, MariaDB, PostgreSQL, Redis, GraphQL)</description>
  <executable>%BASE%\Kuonen.Data.KuonenSql.Server.exe</executable>
  <arguments>1433 6379</arguments>
  <workingdirectory>%ProgramData%\KuonenSQL</workingdirectory>
  <env name="KUONENSQL_DATEN_PFAD" value="%ProgramData%\KuonenSQL\Daten" />
  <env name="DOTNET_BUNDLE_EXTRACT_BASE_DIR" value="%ProgramData%\KuonenSQL\net" />
  <!-- Kennwort von sa: gilt ab dem Start und bleibt als Hash im Datenordner; danach darf der Wert wieder leer werden. -->
  <env name="KUONENSQL_SA_PASSWORD" value="" />
  <!-- KSQL: TDS mit dem Kern als Sprache und ehrlicher Kennung (K33.1); leer = aus. -->
  <env name="KUONENSQL_KSQL_PORT" value="1333" />
  <!-- Weitere Zugänge auf dieselbe Ablage; leer = aus. -->
  <env name="KUONENSQL_MYSQL_PORT" value="" />
  <env name="KUONENSQL_POSTGRESQL_PORT" value="" />
  <env name="KUONENSQL_GRAPHQL_PORT" value="" />
  <startmode>Automatic</startmode>
  <delayedAutoStart>true</delayedAutoStart>
  <onfailure action="restart" delay="10 sec" />
  <stoptimeout>60 sec</stoptimeout>
  <logpath>%ProgramData%\KuonenSQL\Protokoll</logpath>
  <log mode="roll-by-size">
    <sizeThreshold>10240</sizeThreshold>
    <keepFiles>8</keepFiles>
  </log>
</service>

Im Betrieb

Protokoll laufend ansehen

PowerShell
Get-Content "$env:ProgramData\KuonenSQL\Protokoll\KuonenSQL-Dienst.out.log" -Wait

Neu starten

PowerShell
Restart-Service KuonenSQL

Auf eine neue Fassung

PowerShell
Stop-Service KuonenSQL
Copy-Item .\Kuonen.Data.KuonenSql.Server.exe "$env:ProgramFiles\KuonenSQL\"
Start-Service KuonenSQL

Entfernen (die Daten in ProgramData\KuonenSQL bleiben)

PowerShell
Stop-Service KuonenSQL
& "$env:ProgramFiles\KuonenSQL\KuonenSQL-Dienst.exe" uninstall

Gut zu wissen

  • Der Dienst läuft als LocalSystem; Daten und Protokoll liegen unter C:\ProgramData\KuonenSQL.
  • WinSW beendet den Server mit Strg+C und wartet bis zu 60 Sekunden; der Server schreibt in der Zeit seinen Kontrollpunkt.
  • Der Server selbst spricht noch nicht mit der Dienstverwaltung von Windows - darum WinSW. Eine eingebaute Anbindung steht auf der Roadmap.

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.