Entwicklerwerkzeuge
Der Entwicklerbereich der Auris-Konsole bietet eine Suite von Werkzeugen zum Erstellen, Testen und Debuggen von Integrationen mit Auris. Diese Werkzeuge sind darauf ausgelegt, die Zeit zwischen „Ich möchte Auris integrieren” und „Authentifizierung funktioniert in meiner Anwendung” zu reduzieren.
Zugriff auf den Developer Hub unter Konsole → Entwickler → Hub.
Developer-Hub-Übersicht
Der Developer Hub ist eine Landing Page mit sechs Karten, die zu jedem Entwicklerwerkzeug verlinken:
| Werkzeug | Symbol | Beschreibung |
|---|---|---|
| API Explorer | Globus | Alle Auris-API-Endpunkte durchsuchen und testen |
| Token-Decoder | Schlüssel | JWT-Token dekodieren und untersuchen |
| Sandbox | Terminal | API-Aufrufe gegen deinen Tenant testen |
| Quickstarts | Rakete | Interaktiver Einrichtungsassistent für deine Anwendung |
| CLI-Werkzeug | Terminal | Befehlszeilenschnittstellen-Referenz |
| SDK-Übersicht | Paket | Funktionsvergleich über alle SDK-Pakete |
Zusätzlich bietet die Seite Entwicklerdokumentation interne Referenzanleitungen mit Code-Blöcken für häufige Integrationsaufgaben.
API Explorer
Der API Explorer bietet eine durchsuchbare Referenz aller Auris-API-Endpunkte, organisiert in 9 Abschnitte. Zugriff unter Konsole → Entwickler → API Explorer.
API-Abschnitte
| Abschnitt | Endpunkte | Beschreibung |
|---|---|---|
| Auth | Anmeldung, Registrierung, Token-Exchange, Refresh, Abmeldung, MFA-Verifizierung, Magic Link, Soziale Anmeldung | Kern-Authentifizierungsabläufe |
| Benutzer | CRUD, Suche, Aktivieren/Deaktivieren, Metadaten, Sitzungen, 2FA-Verwaltung | Benutzerlebenszyklus-Verwaltung |
| Rollen | CRUD, Berechtigungszuweisung, rollenbasierte Berechtigungsprüfungen | RBAC-Konfiguration |
| Organisationen | CRUD, Mitglieder, Einladungen, SSO-Verbindungen | B2B-Multi-Org-Verwaltung |
| FGA | Modelle, Tuples, Check, Expand, List-Objects | Feingranulare Autorisierung |
| Apps | Anwendungs-CRUD, Geheimnis-Rotation, benutzerdefinierte Ansprüche, M2M-Token | Anwendungskonfiguration |
| Webhooks | CRUD, Test, Übermittlungsverlauf, Geheimnis-Rotation | Ausgehende Webhook-Verwaltung |
| OIDC | Discovery-Dokument, JWKS, Authorize, UserInfo | OpenID Connect Standardendpunkte |
| SCIM | Users, Groups, ServiceProviderConfig, Schemas, Bulk | SCIM 2.0 Provisionierung |
Den API Explorer verwenden
Jeder Abschnitt expandiert zu einzelnen Endpunkten mit:
- HTTP-Methode und Pfad (z. B.
POST /api/auth/token) - Anfrageparameter: Abfrageparameter, Pfadparameter und Anfrage-Body-Schema
- Antwortformat: Beispiel-Erfolgs- und Fehlerantwort-Bodies
- Authentifizierungsanforderung: Welche Endpunkte ein Bearer-Token erfordern und welche öffentlich sind
Der API Explorer ist ein Referenzwerkzeug — er zeigt das Anfrage- und Antwortformat, führt aber keine API-Aufrufe aus. Verwende die Sandbox für Live-Tests.
Token-Decoder
Der Token-Decoder ermöglicht es dir, ein beliebiges JWT einzufügen und seinen dekodierten Inhalt zu sehen. Zugriff unter Konsole → Entwickler → Token-Decoder.
Verwendung
JWT einfügen
Kopiere ein Access Token, ID Token oder ein anderes JWT und füge es in das Textfeld ein.
Dekodierten Output anzeigen
Der Decoder teilt das JWT in seine drei Teile auf und zeigt sie an:
Header:
{
"alg": "RS256",
"kid": "key-id-1",
"typ": "JWT"
}Payload:
{
"sub": "usr_abc123",
"iss": "https://auth.ihrfirmenname.de",
"aud": "ihre-client-id",
"iat": 1739880000,
"exp": 1739880900,
"email": "[email protected]",
"roles": ["editor"],
"acr": "urn:auris:acr:mfa",
"amr": ["pwd", "otp"]
}Token-Gültigkeit prüfen
Der Decoder zeigt:
- Ablaufstatus: Ob das Token noch gültig ist oder abgelaufen ist (Vergleich von
expmit der aktuellen Zeit) - Ausstellungszeit: Für Menschen lesbare „ausgestellt am”-Zeit
- Verbleibende Zeit: Für gültige Token, wie lange bis zum Ablauf
Häufige Anwendungsfälle
- Ansprüche debuggen: Verifizieren, dass benutzerdefinierte Ansprüche, Rollen und Scopes im Token vorhanden sind
- Ablauf prüfen: Feststellen, ob ein
401-Fehler durch ein abgelaufenes Token verursacht wird - ACR/AMR verifizieren: Bestätigen, dass Step-up-Authentifizierungsansprüche nach MFA enthalten sind
- M2M-Token untersuchen:
type: "m2m"und Scope-Ansprüche für Client-Credentials-Token prüfen - DPoP validieren: Auf
cnf.jkt-Anspruch in DPoP-gebundenen Token prüfen
Der Token-Decoder dekodiert den JWT-Payload ohne die Signatur zu verifizieren. Dies ist beabsichtigt — es ist ein Debugging-Werkzeug. In der Produktion immer Signaturen über den JWKS-Endpunkt verifizieren. Siehe Tokens erklärt für Verifizierungsanleitungen.
Sandbox
Die Sandbox bietet eine Live-API-Testumgebung, die mit deinem Tenant verbunden ist. Zugriff unter Konsole → Entwickler → Sandbox.
Funktionsweise
Die Sandbox füllt Authentifizierungs-Header vorab mit deinem aktuellen Admin-Session-Token und dem x-tenant-Header mit deiner Tenant-ID. Du kannst:
- Einen API-Endpunkt aus dem Dropdown auswählen (in denselben 9 Abschnitten wie der API Explorer organisiert)
- Anfrageparameter ausfüllen (Pfadparameter, Abfrageparameter, Body)
- Auf Senden klicken, um die Anfrage gegen die Live Auris-API auszuführen
- Den Antwort-Statuscode, -Header und -Body anzeigen
Vorab ausgefüllter Kontext
| Feld | Wert | Quelle |
|---|---|---|
| Basis-URL | Deine Auris-API-URL | Aus der Tenant-Konfiguration |
| Authorization | Bearer {ihr-admin-token} | Aus deiner aktuellen Konsolsitzung |
| x-tenant | Dein Tenant-Slug | Aus deiner aktuellen Konsolsitzung |
Das bedeutet, du kannst sofort Endpunkte testen, ohne manuell Header zu konstruieren.
Beispiel: Eine Berechtigungsprüfung testen
- Wähle
POST /api/roles/checkaus dem Endpunkt-Dropdown - Gib den Anfrage-Body ein:
{
"userId": "usr_abc123",
"permission": "view:invoices",
"applicationId": "app_xyz789"
}- Klicke auf Senden
- Sieh die Antwort:
{
"ok": true,
"data": {
"allowed": true,
"source": "role_permission",
"role": "editor"
}
}Quickstarts
Der Quickstarts-Assistent bietet schrittweise Anleitungen zur Integration von Auris in deine Anwendung. Zugriff unter Konsole → Entwickler → Quickstarts.
Interaktiver Einrichtungsassistent
Der Assistent führt durch drei Schritte:
Anwendung auswählen
Wähle eine bestehende Anwendung aus deinem Tenant oder klicke auf Anwendung erstellen, um eine neue zu registrieren. Der Assistent benötigt eine Anwendung, um clientId und domain in Code-Snippets vorab auszufüllen.
Framework auswählen
Wähle dein Entwicklungs-Framework. Jede Framework-Karte zeigt das entsprechende SDK-Paket:
| Framework | SDK-Paket | Beschreibung |
|---|---|---|
| JavaScript | @auris/js | Vanilla JavaScript (Browser oder Node.js) |
| React | @auris/react | React Provider + Hooks |
| Next.js | @auris/nextjs | Server-Helfer + Edge Middleware |
| PHP | auris/sdk | Composer-Paket für PHP-Anwendungen |
| WordPress | auris-sso | WordPress SSO Plugin |
| Laravel | auris/sdk | PHP SDK mit Laravel-spezifischer Anleitung |
Den Code-Snippets folgen
Der Assistent zeigt framework-spezifischen Code mit vorab ausgefüllter clientId und Domain deiner Anwendung:
Installation:
npm install @auris/reactProvider-Einrichtung:
import { AurisProvider } from '@auris/react'
function App({ children }) {
return (
<AurisProvider
domain="auth.ihrfirmenname.de"
clientId="ihre-tatsächliche-client-id"
>
{children}
</AurisProvider>
)
}Anmelde-Schaltfläche:
import { useAuris } from '@auris/react'
function LoginButton() {
const { loginWithRedirect, isAuthenticated, user } = useAuris()
if (isAuthenticated) {
return <p>Willkommen, {user.name}</p>
}
return <button onClick={() => loginWithRedirect()}>Anmelden</button>
}Erweiterte Themen
Unterhalb des Haupt-3-Schritt-Assistenten enthält die Quickstarts-Seite einen Abschnitt Erweiterte Themen mit Code-Snippets für:
| Thema | Beschreibung |
|---|---|
| M2M-Authentifizierung | Client-Credentials-Token-Exchange |
| Berechtigungen (JS) | Berechtigungen mit @auris/js prüfen |
| Berechtigungen (React) | usePermissions und PermissionGate |
| Berechtigungen (Next.js) | Server-Helfer requirePermission und checkPermission |
| FGA-Prüfungen | Feingranulare Autorisierungs-Tuple-Prüfungen |
| Management API | Server-seitige Benutzer-/Rollen-/Org-Verwaltung via M2M |
| Webhook-Verifizierung | HMAC-SHA256-Signaturverifizierung |
| JWT-Verifizierung | Lokale Token-Verifizierung mit JWKS |
Jedes Thema enthält ein funktionierendes Code-Beispiel mit vorab ausgefüllten Anmeldedaten deiner Anwendung.
CLI-Werkzeug
Die CLI-Werkzeug-Referenzseite dokumentiert die auris-Befehlszeilenschnittstelle zur Verwaltung deines Tenants von einem Terminal aus. Zugriff auf die Referenz unter Konsole → Entwickler → CLI.
Verfügbare Befehle
| Befehl | Beschreibung |
|---|---|
auris init | Ein Projekt mit Auris-Konfiguration initialisieren |
auris login | Mit deinem Auris-Tenant authentifizieren |
auris users list | Benutzer im Tenant auflisten |
auris users create | Einen neuen Benutzer erstellen |
auris roles list | Rollen auflisten |
auris roles create | Eine neue Rolle erstellen |
auris orgs list | Organisationen auflisten |
auris apps list | Anwendungen auflisten |
auris logs tail | Prüfprotokolle in Echtzeit streamen |
auris actions list | Actions-Engine-Regeln auflisten |
auris fga check | Eine FGA-Prüfung von der Befehlszeile ausführen |
auris import | Benutzer aus CSV/JSON importieren |
auris export | Benutzer nach CSV/JSON exportieren |
Installation
npm install -g @auris/cliAuthentifizierung
Die CLI verwendet denselben OAuth2-Ablauf wie die Konsole. Das Ausführen von auris login öffnet ein Browserfenster zur Authentifizierung und speichert das Token lokal.
SDK-Übersicht
Die SDK-Übersichtsseite vergleicht Funktionen über die drei SDK-Pakete hinweg. Zugriff unter Konsole → Entwickler → SDKs.
Funktionsvergleich
| Funktion | @auris/js | @auris/react | @auris/nextjs |
|---|---|---|---|
| OAuth2 + PKCE-Anmeldung | Ja | Ja | Ja |
| Magic-Link-Anmeldung | Ja | Ja | Ja |
| Soziale Anmeldung | Ja | Ja | Ja |
| Token-Verwaltung | Ja | Ja | Ja |
| Auto-Refresh | Ja | Ja | Ja |
| Berechtigungsprüfungen | Ja | Ja (Hooks) | Ja (Server) |
| FGA-Prüfungen | Ja | Ja (Hooks) | Ja (Server) |
| Management API (M2M) | Ja | Nein | Ja (Server) |
| Webhook-Verifizierung | Ja | Nein | Nein |
| JWT-Lokalverifizierung | Ja | Nein | Ja |
| React Provider | Nein | Ja | Ja |
| React Hooks | Nein | Ja | Ja |
| Server-Helfer | Nein | Nein | Ja |
| Edge Middleware | Nein | Nein | Ja |
PermissionGate-Komponente | Nein | Ja | Ja |
AuthGuard-Komponente | Nein | Ja | Ja |
Paketdetails
| Paket | Abhängigkeiten | Bundle-Größe | Umgebungen |
|---|---|---|---|
@auris/js | Keine Abhängigkeiten | ~8 KB gzipped | Browser, Node.js, Edge |
@auris/react | Abhängig von @auris/js | ~12 KB gzipped | Browser (React 18+) |
@auris/nextjs | Abhängig von @auris/react | ~15 KB gzipped | Browser + Server + Edge (Next.js 13+) |
Entwicklerdokumentation
Die Entwicklerdokumentationsseite bietet interne Referenzanleitungen, die in einklappbaren Abschnitten organisiert sind. Zugriff unter Konsole → Entwickler → Docs.
Anleitungsabschnitte
| Abschnitt | Abgedeckte Themen |
|---|---|
| Einstieg | Installation, grundlegende Einrichtung, erste Anmeldung |
| Authentifizierung | Anmeldemethoden, Token-Handling, Abmeldung, Sitzungsverwaltung |
| Autorisierung | RBAC-Berechtigungsprüfungen, FGA-Integration, benutzerdefinierte Ansprüche |
| Webhooks | Endpunkte einrichten, Signaturverifizierung, Ereignistypen |
| Server-seitig | M2M-Token, Management API, Server-seitiges Rendering |
| OIDC | Discovery-Dokument, JWKS, Standardendpunkte |
Jeder Abschnitt enthält:
- Prägnanten erklärenden Text
- Code-Blöcke mit Syntaxhervorhebung
- Kopieren-Schaltflächen auf allen Code-Blöcken
- Schnelllinks zur vollständigen Dokumentation für tieferes Lesen
Die Entwicklerdokumentationsseite ist als Kurzreferenz konzipiert, die innerhalb der Konsole bleibt, und vermeidet Kontextwechsel zur externen Dokumentation für häufige Aufgaben.
Zugehörige Anleitungen
- SDKs — Vollständige SDK-Dokumentation
- API-Referenz — Vollständige API-Endpunkt-Dokumentation
- Anwendungen — In Quickstarts verwendete Anwendungen konfigurieren
- Quickstarts-Tutorial — Vollständige Einstiegsanleitung