Self-Hosting

Ihr Produkt mit Ihrer Instanz verbinden

Machen Sie Self-Hosting wirksam: Richten Sie die Apps Ihrer Kunden auf Ihre eigene Keyright-Instanz aus. Produkt anlegen, seinen Signaturschlüssel erzeugen, den öffentlichen Schlüssel und Ihre Basis-URL im SDK einbetten, eine Lizenz ausstellen und aktivieren — dieselben SDKs wie beim gehosteten Keyright, nur mit Ihrem Produktschlüssel und Ihrer URL.

Dies ist der Schritt, der Self-Hosting wirksam macht: Die Apps Ihrer Kunden müssen sich gegen Ihre Keyright-Instanz lizenzieren, nicht gegen unsere. Die SDKs (NuGet, npm, PyPI, Maven) sind dieselben, die die Integrationsleitfäden für das gehostete Keyright beschreiben — nichts ist fest auf einen Delta1-Endpunkt verdrahtet. Der gesamte Rundgang läuft gegen Ihre Instanz; unten steht $BASE für Ihre Basis-URL (aus Bereitstellen → Prüfen) und $TOKEN für Ihr KEYRIGHT_ADMIN_TOKEN.

Schritt 1 — Das Produkt anlegen

Produkte existieren erst, wenn Sie sie anlegen (der Signaturschlüssel-Aufruf in Schritt 2 liefert andernfalls 404). Im Dashboard (Products → Add product) oder über die API:

curl -X POST -H "X-Admin-Token: $TOKEN" -H "content-type: application/json" \
     $BASE/admin/products -d '{"name":"Acme App","slug":"acme-app"}'

Schritt 2 — Den Signaturschlüssel des Produkts erzeugen

Das ist der Schlüssel, der acme-app-Lizenzen signiert; betten Sie seine öffentliche Hälfte in Ihre App ein.

curl -X POST -H "X-Admin-Token: $TOKEN" $BASE/admin/products/acme-app/signing-key
# -> { "signingPublicKey": "MIIBIjANBgkq...", "rotated": false, ... }

Der private Schlüssel wird erzeugt und in Ihrer Datenbank, KEK-verschlüsselt gespeichert — er verlässt Ihre Instanz nie. Kopieren Sie den zurückgegebenen öffentlichen Schlüssel. (Alternativ verwenden Sie über KEYRIGHT_SIGNING_KEY einen mandantenweiten Schlüssel und betten GET $BASE/admin/public-key ein — ein produktspezifischer Schlüssel ist aber die einfachste, eindeutige Wahl.)

Schritt 3 — Diesen öffentlichen Schlüssel in Ihre App einbetten

Über das SDK — das prüft Lizenzen offline, ohne jeden Aufruf an Ihren Server:

Runtime	Option	Wert
.NET (`Keyright.NET`)	`PublicKeyBase64`	der öffentliche Schlüssel Ihres Produkts (Schritt 2)
Node (`keyright`)	`publicKeyBase64`	der öffentliche Schlüssel Ihres Produkts
Python (`keyright`)	`public_key_base64`	der öffentliche Schlüssel Ihres Produkts
Java (`com.delta1labs:keyright`)	`publicKeyBase64`	der öffentliche Schlüssel Ihres Produkts

Schritt 4 — Das SDK auf Ihre Instanz ausrichten

Für Online-Aktivierung/-Validierung/-Metering — setzen Sie die Service-URL auf die Basis-URL Ihrer Instanz ($BASE):

Runtime	Option	Wert
.NET	`ServiceUrl`	`https://licensing.acme.example`
Node	`serviceUrl`	`https://licensing.acme.example`
Python	`service_url`	`https://licensing.acme.example`
Java	`serviceUrl`	`https://licensing.acme.example`

.NET-Beispiel (Node, Python und Java sind bis auf die Benennung identisch — siehe deren Integrationsleitfäden; für einen Self-Service-Testschlüssel ruft Ihre App POST <base>/v1/trial direkt auf, was den Schlüssel per E-Mail an den Kunden sendet — der ihn dann eingibt, und Ihre App aktiviert ihn wie jeden bezahlten Schlüssel):

using Keyright.Client;

static readonly KeyrightClient License = KeyrightClient.Initialize(new KeyrightOptions
{
    Product         = "acme-app",                        // Ihr Produkt-Slug auf Ihrer Instanz
    PublicKeyBase64 = "MIIBIjANBgkq...",                 // der öffentliche Schlüssel Ihres Produkts (Schritt 2)
    ServiceUrl      = "https://licensing.acme.example",  // Basis-URL Ihrer Instanz (Schritt 4); weglassen, wenn nur offline
});

Schritt 5 — Eine Lizenz an einen Kunden ausstellen

Definieren Sie optional ein Tier (eine Platzanzahl + Entitlement-Vorlage) und stellen Sie dann einen Schlüssel aus:

# optional: ein wiederverwendbares Tier
curl -X POST -H "X-Admin-Token: $TOKEN" -H "content-type: application/json" \
     $BASE/admin/products/acme-app/tiers -d '{"name":"pro","seats":3,"entitlements":{"export":"true"}}'

# eine Lizenz ausstellen ("id" weglassen, um den Schlüssel automatisch zu erzeugen)
curl -X POST -H "X-Admin-Token: $TOKEN" -H "content-type: application/json" \
     $BASE/admin/licenses -d '{"licensee":"Acme Inc.","product":"acme-app","tier":"pro","seats":3,"email":"owner@acme.com"}'
# -> HTTP 201 { "id":"LIC-XXXX...", "product":"acme-app", "tier":"pro", "seats":3, "used":0, ... }

Die id (LIC-…) ist der Schlüssel, den Sie dem Kunden übergeben. seats auf der Lizenz überschreibt den Standardwert des Tiers.

Schritt 6 — Die App des Kunden aktiviert

Der Activate-Aufruf des SDK (oder ein rohes POST $BASE/v1/activate mit dem Body { "key", "machineId", "product" }, ohne Auth) bindet die Maschine, belegt einen Platz und gibt einen signierten Lease zurück, den Ihre App zwischenspeichert und offline erneut prüft:

LicenseInfo info = await License.ActivateAsync(customerKey);   // online: bindet diese Maschine
if (info.IsPaid && License.IsEnabled("export")) { /* freischalten */ }

Das ist der ganze Unterschied zum gehosteten Keyright: Ihr Produktschlüssel und Ihre URL. Die /v1/*-Endpunkte, die Lizenz-/Lease-Formate und jeder SDK-Aufruf sind identisch. Vollständige Rundgänge pro Sprache: .NET, Node.js, Python, Java oder die rohe HTTP-API (die die exakten /v1/*-Request-Bodys dokumentiert).