Micro-SaaS mit Keycloak – warum sich die Kombination lohntn Marco Griep

Micro-SaaS mit Keycloak – warum sich die Kombination lohntn

Veröffentlicht:

Wer ein Micro-SaaS Produkt plant, steht sehr schnell vor denselben Fragen: Wie sichere ich Logins zuverlässig ab? Wie manage ich Benutzer, Rollen und Rechte? Und wie integriere ich Single Sign-On (SSO), ohne das komplette Budget in eine Eigenentwicklung zu stecken? Einfach die Authentifizierungs- und Benutzerverwaltungslogik selbst zu bauen, ist nicht nur zeitaufwendig, sondern auch riskant – gerade im SaaS-Umfeld, wo Sicherheit und Skalierbarkeit entscheidend sind. Genau an dieser Stelle spielt Keycloak seine Stärken aus. Die Open-Source-Lösung übernimmt die komplexen Aufgaben rund um Benutzerverwaltung, Authentifizierung und Single Sign-On, während Sie sich auf Ihr eigentliches SaaS Produkt konzentrieren können.

In diesem Leitfaden zeige ich, wie Sie Keycloak gezielt für Ihr Micro-SaaS einsetzen können – von der Architektur über die Integration bis hin zu Sicherheits- und Betriebsaspekten.

Was ist ein Micro-SaaS und welche Rolle spielt Keycloak?

Micro-SaaS beschreibt ein sehr fokussiertes SaaS Produkt mit meist klar abgegrenzter Zielgruppe und Funktionsbreite. Technisch setzen viele moderne Micro-SaaS-Lösungen auf:

  • eine schlanke Codebasis
  • Microservices oder modulare Architektur
  • Cloud-native Infrastruktur (Docker, Kubernetes, Managed DB etc.)
  • API-first-Ansatz

Genau in diesem Setup ist eine eigene Implementierung von Benutzerverwaltung, Authentifizierung und Single Sign-On oft ineffizient:

  • Sicherheitsrelevante Themen erfordern Spezialwissen
  • OAuth2/OIDC und SAML-Implementierungen sind fehleranfällig
  • Multi-Tenant-Fähigkeit (pro Kunde/Organisation eigene Nutzer) ist komplex
  • Compliance-Anforderungen (z. B. Protokollierung, Passwort-Richtlinien) kosten Zeit

Keycloak löst diese Probleme, indem es als externe, zentrale Komponente Ihre gesamte Identity- und Access-Management (IAM)-Schicht übernimmt.

Keycloak im Überblick – zentrale Funktionen für Ihr Micro-SaaS

Keycloak ist ein Open-Source Identity and Access Management System, das speziell für moderne Web- und Cloud-Anwendungen entwickelt wurde. Für die SaaS Entwicklung und insbesondere Micro-SaaS sind vor allem folgende Funktionen relevant:

1. Benutzerverwaltung out of the box

  • Benutzer anlegen, bearbeiten, deaktivieren
  • Selbstregistrierung (optional)
  • Passwort-Reset via E-Mail
  • Attribute (z. B. Firma, Plan, Kundennummer) verwalten
  • Gruppen und Rollen organisieren

Damit sparen Sie sich Ihr eigenes User-Management-Modul inklusive UI, Validierung und Security-Edge-Cases.

2. Authentifizierung mit Standards

Keycloak unterstützt moderne Standards wie:

  • OpenID Connect (OIDC)
  • OAuth2
  • SAML 2.0

Für Ihr Micro-SaaS ist OIDC meist die erste Wahl. Die Integration in Frontend und Backend erfolgt über standardisierte Flows (Code Flow für Web-Apps, PKCE für SPAs etc.).

3. Single Sign-On und Single Logout

Mit Keycloak können sich Nutzer einmal einloggen und nahtlos auf mehrere:

  • Microservices
  • Admin-Frontends
  • Kundenportale
  • Partner-Anwendungen

zugreifen. Dieses Single Sign-On steigert die Nutzerfreundlichkeit. Gleichzeitig bietet Keycloak Single Logout, um Sessions sicher zu invalidieren.

4. Rollen- und Rechtekonzept

Keycloak unterstützt:

  • Realm-Rollen (global)
  • Client-Rollen (spezifisch für eine Anwendung)
  • Gruppen und Rollenzuordnung über Gruppen

Ihr Micro-SaaS kann so differenzierte Berechtigungen abbilden, ohne selbst ein Rollenmodell implementieren zu müssen. Im Access Token stehen die Rollen zur Verfügung und können im Backend geprüft werden.

5. Multi-Faktor-Authentifizierung (MFA)

Sicherheit ist im SaaS Umfeld geschäftskritisch. Keycloak bietet u. a.:

  • TOTP (z. B. Google Authenticator)
  • WebAuthn / Security Keys (abhängig von Version/Setup)
  • Richtlinien für Passwörter und Login-Schutz

Sie können MFA optional je Kunde, je Rolle oder je Anwendung erzwingen.

Realms und Clients – die Bausteine der Keycloak-Architektur

In Keycloak sind Realms und Clients zentrale Konzepte:

  • Realm: Eine isolierte Umgebung, die Benutzer, Rollen, Gruppen und Clients enthält. In einem Realm können Sie mehrere Clients (Anwendungen) verwalten. Realms sind ideal für die Trennung von Umgebungen (z. B. Test vs. Produktion) oder sogar von Kunden (bei sehr hoher Isolation).
  • Client: Repräsentiert eine Anwendung, die Keycloak für Authentifizierung und Autorisierung nutzt. Clients können unterschiedliche Protokolle (OIDC, SAML) und Access Types (public, confidential) haben.

Ich habe mehrere Websites / Webapplikationen in Keycloak integriert und nutze für jede Umgebung einen eigenen Realm. Das ermöglicht eine klare Trennung von Test- und Produktionsdaten und erleichtert die Verwaltung von Benutzerkonten und Berechtigungen. In der Praxis habe ich festgestellt, dass die Nutzung von Realms für verschiedene Umgebungen eine effektive Methode ist, um die Sicherheit und Organisation meiner Anwendungen zu gewährleisten.

Architektur: Keycloak in ein Micro-SaaS Produkt integrieren

Für ein Micro-SaaS mit Keycloak hat sich folgende Grundarchitektur bewährt:

  1. Keycloak-Server (eigenes Deployment, On-Prem oder Managed in der Cloud)
  2. API / Backend-Service (Ihre Business-Logik)
  3. Frontend (SPA, klassische Web-App oder Mobile App)
  4. Datenbank für Ihr Produkt (Anwendungsdaten)
  5. Optional: API-Gateway oder Ingress mit Authz-Integration

Realms und Mandanten (Tenants)

Eine zentrale Designfrage ist, wie Sie Mandanten (Kundenorganisationen) abbilden:

  • Variante A – Ein Realm für alle Kunden

    • Kunden über Gruppen/Attribute unterscheiden
    • Vorteile: einfacher Betrieb, weniger Overhead
    • Geeignet für klassische Multi-Tenant-Micro-SaaS

  • Variante B – Ein Realm pro Kunde

    • vollständige Trennung von Benutzerverwaltung und Konfiguration
    • Vorteile: hohe Isolation, kundenspezifische Konfiguration
    • Nachteil: mehr Administrationsaufwand

Für viele typische Micro-SaaS-Usecases ist Variante A (ein Realm, Mandanten über Attribute/Gruppen) vollkommen ausreichend.

Konkrete Schritte: Von der Idee zum Micro-SaaS mit Keycloak

1. Keycloak aufsetzen

Für Entwicklung und Test eignet sich ein Docker-Setup. Ich verwende dazu Docker-Compose und setze Keycloak hinter einen Traefik Proxy, um TLS und Routing zu managen. Ein einfaches Keycloak-Setup könnte so aussehen:

mkdir -p /srv/dockerfiles/keycloak
cd /srv/dockerfiles/keycloak
nano docker-compose.yml

Keycloak docker-compose.yml:

services:
  keycloak:
    image: local/keycloak:26.5.5
    restart: always
    build:
      context: .
      args:
        - "KEYCLOAK_VERSION=26.5.5"
    command: start --proxy-headers xforwarded --http-enabled true
    volumes:
      - ./plugins:/opt/keycloak/providers
      - ./kc_data:/opt/keycloak/data
      - ./keycloak/realms/export:/tmp/export
    environment:
      KEYCLOAK_ADMIN: admin
      KEYCLOAK_ADMIN_PASSWORD: <BITTE_ÄNDERN> # Anpassen!
      KC_DB: mysql
      KC_DB_URL_HOST: <DEIN_DB_HOST>  # Anpassen!
      KC_DB_URL_DATABASE: <DEIN_DB_NAME> # Anpassen!
      KC_DB_USERNAME: <DEIN_DB_USER> # Anpassen!
      KC_DB_PASSWORD: <KC_DB_PASSWORD> # Anpassen!
      KC_HOSTNAME: auth.domain.de # Anpassen!
      KC_HTTP_RELATIVE_PATH: /auth
      KC_PROXY_HEADERS: xforwarded
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.keycloak.rule=Host(`auth.domain.de`)" # Anpassen!
      - "traefik.http.routers.keycloak.entrypoints=web"
      - "traefik.http.routers.keycloak.entrypoints=websecure"
      - "traefik.http.routers.keycloak.tls.certresolver=myresolver"
    networks:
      - traefik_common_net

networks:
  traefik_common_net:
    external: true

In diesem Setup wird Keycloak mit einer MySQL-Datenbank betrieben, die Sie entsprechend anpassen müssen. In einer Dockerfile können Sie zusätzlich Plugins oder Anpassungen vornehmen. Ich setze hier eigentlich nur die Version.

Dockerfile und die MySQL Treiber

Dockerfile:

RG KEYCLOAK_VERSION
FROM quay.io/keycloak/keycloak:${KEYCLOAK_VERSION}

ENV KC_DB=mysql
ENV KC_HEALTH_ENABLED=true
ENV KC_METRICS_ENABLED=true

ENV KC_HTTP_RELATIVE_PATH=/auth
RUN /opt/keycloak/bin/kc.sh build

Jetzt müssen wir noch Traefik so konfigurieren, dass er die Anfragen an Keycloak weiterleitet. Das erfolgt über die Labels im Docker-Compose-File.

mkdir -p /srv/dockerfiles/traefik
cd /srv/dockerfiles/traefik
nano docker-compose.yml

Docker-Compose für Traefik

services:
  traefik:
    image: "traefik:latest"
    restart: always
    container_name: "traefik"
    command:
      - "--api.insecure=false"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--certificatesresolvers.myresolver.acme.httpchallenge=true"
      - "--certificatesresolvers.myresolver.acme.httpchallenge.entrypoint=web"
      - "--certificatesresolvers.myresolver.acme.email=mail@marcogriep.de"  # Anpassen!
      - "--certificatesresolvers.myresolver.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - "./letsencrypt:/letsencrypt"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    networks:
      - common_net

networks:
  common_net:
    driver: bridge

Danach ist das Admin-Interface typischerweise unter der jeweiligen Domain / Subdomain erreichbar inkl. LetsEncrypt Zertifikat.

Probleme mit der Installation

Gerne helfen wir Ihnen bei der Installation und Konfiguration von Keycloak.

Jetzt Kontakt aufnehmen

2. Realm und Client für Ihr Micro-SaaS anlegen

  1. Im Admin-Interface neuen Realm erstellen (z. B. micro-saas-realm).
  2. Unter Clients eine neue Anwendung erstellen, z. B.:
    • Client ID: micro-saas-frontend
    • Client Protocol: openid-connect
    • Access Type: public (für SPA) oder confidential (für Backend).
  3. Valid Redirect URIs setzen (z. B. https://app.mein-micro-saas.de/*).

Für ein Backend-API legen Sie zusätzlich einen confidential Client an, dem Sie einen Client-Secret zuweisen.

3. Integration in das Frontend

Das Frontend nutzt einen OIDC-Client (z. B. JavaScript, React, Angular, Vue) und kommuniziert direkt mit Keycloak. Typischer Ablauf:

  1. Benutzer ruft Ihre App auf
  2. Kein gültiges Token vorhanden → Redirect zum Keycloak-Login
  3. Benutzer meldet sich an
  4. Keycloak leitet mit Code zurück
  5. Frontend tauscht Code gegen Access Token / ID Token
  6. Tokens werden im Browser (sicher) gespeichert und mit API-Requests gesendet

Beispielcode aus meiner VueJS Anwendung mit keycloak-js:

import Keycloak from "keycloak-js";

let keycloak = null;

export const initializeKeycloak = () => {
  keycloak = new Keycloak({
    url: "https://meine-domain.de/auth", // Anpassen!
    realm: "micro-saas-realm",
    clientId: "micro-saas-frontend",
  });

  return new Promise((resolve, reject) => {
    keycloak
      .init({
        onLoad: "check-sso", // Kein erzwungener Login
        silentCheckSsoRedirectUri:
          window.location.origin + "/silent-check-sso.html",
        pkceMethod: "S256",
        flow: "standard",
      })
      .then(() => {
        if (keycloak && keycloak.authenticated) {
          console.log("Keycloak: Authenticated");
        } else {
          console.log("ℹKeycloak: Not authenticated, but continuing");
        }
        resolve(keycloak);
      })
      .catch((error) => {
        console.error("Keycloak init failed:", error);
        reject(error);
      });
  });
};

export const useKeycloak = () => {
  return keycloak;
};

export const login = () => {
  if (keycloak) {
    keycloak.login();
  }
};

export const logout = () => {
  if (keycloak) {
    keycloak.logout();
  }
};

export const isAuthenticated = () => {
  return !!(keycloak && keycloak.authenticated);
};

export const getToken = () => {
  return keycloak ? keycloak.token : null;
};

export const updateToken = (successCallback) => {
  if (keycloak) {
    keycloak
      .updateToken(30)
      .then(successCallback)
      .catch(() => {
        console.warn("⚠️ Failed to refresh token");
      });
  }
};

4. Integration in das Backend (API)

Ihr Backend überprüft die JWT Access Tokens, die vom Frontend gesendet werden. Je nach Technologie-Stack gibt es Bibliotheken bzw. Middleware:

  • Java / Spring Boot: spring-boot-starter-oauth2-resource-server
  • Node.js: passport, express-jwt, keycloak-connect
  • .NET: AddJwtBearer mit Authority auf Keycloak. Microsoft IdentityModel unterstützt OIDC/JWT-Validation out of the box
  • Go, Python, PHP: entsprechende OIDC/JWT-Libraries

Beispiel-Konzept (unabhängig von der Sprache):

  1. Public Key / JWKS von Keycloak abrufen
  2. Signature, Issuer, Audience und Ablaufzeit des Tokens prüfen
  3. Rollen aus den Token-Claims lesen (z. B. realm_access.roles)
  4. Backend-Routen entsprechend absichern (RBAC)

Damit liegt die Autorisierung (wer darf was) in Ihrer Business-Logik, während die Authentifizierung (wer ist der Nutzer) Keycloak übernimmt.

Benutzerverwaltung im Micro-SaaS mit Keycloak strukturieren

Benutzer anlegen und verwalten

Je nach Geschäftsmodell können Sie:

  • Benutzer durch einen internen Admin anlegen lassen
  • Selbstregistrierung erlauben (Keycloak Registrierungsseite)
  • Benutzer via API von Ihrem Backend aus anlegen (Admin REST API)

Für Automatisierungen (z. B. Onboarding neuer Firmenkunden) nutzen Sie die Keycloak Admin REST API, um:

  • Organisationen (als Gruppe) anzulegen
  • Benutzer zu erstellen und Gruppen/Rollen zuzuweisen
  • Attribute wie Kundennummer, Plan, Limits zu setzen

Rollen, Gruppen und Permissions

Strukturbeispiel für ein typisches Micro-SaaS:

  • Rollen:

    • tenant_admin (Kunden-Admin)
    • tenant_user (normaler Benutzer)
    • support (Ihr Support-Team)

  • Gruppen:

    • Eine Gruppe pro Mandant, z. B. acme-corp, beta-ltd
    • Die Gruppen enthalten die jeweiligen Benutzer

  • Zugehörigkeit:

    • Benutzer X ist Mitglied von acme-corp und hat Rolle tenant_admin
    • Benutzer Y ist Mitglied von acme-corp und hat Rolle tenant_user

Im Access Token stehen sowohl Gruppen als auch Rollen. Damit können Sie im Backend sicherstellen, dass:

  • Benutzer nur auf Daten ihres Mandanten zugreifen
  • Admins nur ihre eigene Organisation verwalten
  • Ihr Support nur lesend auf bestimmte Kundendaten zugreifen darf

Single Sign-On in der Micro-SaaS Landschaft

Viele Micro-SaaS-Produkte wachsen im Laufe der Zeit:

  • eigenes Admin-Portal
  • API-Konsole oder Developer-Portal
  • mehrere Frontends für unterschiedliche Zielgruppen
  • Integrationen mit Partner-Tools

Mit Keycloak können Sie all diese Anwendungen als Clients in einem Realm verwalten. Vorteile:

  • Ein Login für mehrere Anwendungen
  • Zentrales Session-Management
  • Einheitliche Sicherheitsrichtlinien
  • Nahtlose User Experience

Beispielszenario:

  • Der Kunde meldet sich im Haupt-Frontend an
  • Von dort wechselt er in das Reporting-Portal
  • Dank SSO erfolgt kein erneuter Login, da Keycloak die Session erkennt

Für Mobile Apps können Sie entweder direkt OIDC nutzen oder über einen Authorization Code Flow mit PKCE arbeiten.

Sicherheit und Best Practices für Micro-SaaS mit Keycloak

Technische Sicherheit

  • TLS überall: Keycloak sollte ausschließlich über HTTPS erreichbar sein
  • Starke Passwortrichtlinien im Realm konfigurieren
  • MFA für sensible Rollen (z. B. Tenant-Admins) erzwingen
  • Token-Lifetimes sinnvoll wählen (Balance zwischen Sicherheit und Usability)
  • Refresh Tokens begrenzt zulassen und Rotation aktivieren

Betriebsaspekte

  • Backups der Keycloak-Datenbank (Benutzer, Konfiguration) einplanen
  • Monitoring (Health Checks, Metriken) integrieren
  • Updates regelmäßig einspielen (Security-Fixes)
  • Staging-Umgebung für Konfigurationsänderungen nutzen

Multi-Tenant-Aspekte

  • Mandanten-ID konsistent als Attribut im Benutzer oder in der Gruppe hinterlegen
  • Zugriff im Backend immer an die Mandanten-ID koppeln
  • Optional: Client-Scopes verwenden, um zusätzliche Claims (z. B. Plan, Limit) in Tokens auszuliefern

Vorteile für SaaS Entwicklung und Micro-SaaS Teams

Die Nutzung von Keycloak bringt für IT-Leiter, Softwareentwickler, IT-Administratoren und Geschäftsführer konkrete Vorteile:

  • Schnellere Time-to-Market
    Die Implementierung von Benutzerverwaltung und Authentifizierung wird drastisch beschleunigt.

  • Reduziertes Sicherheitsrisiko
    Sie lehnen sich an etablierte Standards an, statt eigene Authentifizierungslogik zu pflegen.

  • Bessere Skalierbarkeit
    Keycloak ist darauf ausgelegt, viele Clients und Benutzer performant zu bedienen.

  • Flexibilität bei Integrationen
    Dank SAML und OIDC können Sie Unternehmens-SSO (z. B. Azure AD, Okta, AD FS) später relativ einfach anbinden.

  • Saubere Trennung von Concerns
    Ihr Micro-SaaS-Backend konzentriert sich auf Business-Logik, nicht auf IAM.

Typische Stolpersteine – und wie Sie sie vermeiden

  1. Undurchdachte Tenant-Strategie

    • Vorab klären: ein Realm vs. mehrere Realms
    • Tenant-Konzept in Rollen/Gruppen/Attributen klar definieren

  2. Fehlende Trennung von Test und Produktion

    • Mindestens je einen Realm bzw. sogar separate Keycloak-Instanzen für Test/Prod nutzen

  3. Zu viel Logik im Frontend

    • Authentifizierung im Frontend, Autorisierung im Backend – Tokens dort serverseitig prüfen

  4. Unzureichende Dokumentation

    • Die Keycloak-Konfiguration (Clients, Rollen, Mappings) versionieren und dokumentieren
    • Möglichst viel über Skripte/Automatisierung (Infrastructure as Code) abbilden

Fazit – Micro-SaaS mit Keycloak als stabile Basis für Wachstum

Ein Micro-SaaS lebt davon, dass es sich schnell entwickeln, testen und skalieren lässt – ohne ständig sicherheitskritische Basisfunktionen neu erfinden zu müssen.

Mit Keycloak erhalten Sie eine mächtige Plattform für:

  • Benutzerverwaltung
  • Authentifizierung mit OAuth2/OIDC/SAML
  • Single Sign-On über mehrere Anwendungen
  • Flexible Rollen- und Rechteverwaltung
  • Erweiterungen wie MFA, Identity Brokering und Enterprise-SSO

Damit schaffen Sie für Ihr SaaS Produkt eine stabile, sichere und erweiterbare Basis – und Ihr Team kann sich auf das konzentrieren, was Ihr Micro-SaaS einzigartig macht: den fachlichen Mehrwert für Ihre Kunden.

Nächster Schritt – lassen Sie sich bei der Integration von Keycloak beraten

Wenn Sie planen, ein neues Micro-SaaS zu entwickeln oder ein bestehendes SaaS Produkt auf Keycloak umzustellen, lohnt sich frühzeitig eine fundierte technische Konzeption. Themen wie Mandantenmodell, Token-Design, Rollenstruktur und Deployment-Strategie entscheiden darüber, wie wartbar und sicher Ihre Lösung später ist.

Ich unterstütze Sie gerne bei:

  • Architektur- und Sicherheitskonzept für Micro-SaaS mit Keycloak
  • Auswahl der passenden Tenant- und Rollenstrategie
  • Integration in Ihre bestehende Systemlandschaft
  • Review bestehender Implementierungen und Performance-Optimierung

Nutzen Sie dafür einfach das Kontaktformular auf der Website und beschreiben Sie kurz Ihr Vorhaben und Ihre aktuelle Systemlandschaft.
Ich melde mich zeitnah mit einem Vorschlag für das weitere Vorgehen und mögliche nächste Schritte in Ihrer SaaS Entwicklung.

JETZT BERATUNG ANFRAGEN

Ich unterstütze Sie gerne bei der Planung und Umsetzung von Keycloak, Entwicklung eines individuelles Keycloak Themes oder der Integration in Ihre bestehende Systemlandschaft.

Jetzt Kontakt aufnehmen