Erstellen Sie eine Multi-Tenant-SaaS-Anwendung: Ein vollständiger Leitfaden von Design bis Implementierung

Wie werden Apps wie Notion, Slack oder Figma erstellt? Diese Multi-Tenant-SaaS-Anwendungen wirken einfach zu bedienen, aber selbst eine zu bauen? Das ist eine andere Geschichte.

Als ich zum ersten Mal darüber nachdachte, ein solches komplexes Konstrukt zu erstellen, explodierte mein Kopf:

• Benutzer benötigen mehrere Anmeldeoptionen (E-Mail, Google, GitHub)
• Jeder Benutzer kann mehrere Organisationen erstellen und zugehören
• Unterschiedliche Berechtigungsstufen innerhalb jeder Organisation
• Unternehmensorganisationen, die eine automatische Beitrittsfunktion für bestimmte E-Mail-Domänen erfordern
• MFA-Anforderungen für sensible Operationen
• ...

"Chef, lassen Sie uns in zwei Wochen über das Produktdesign sprechen. Ich stecke gerade fest."

Aber als ich tatsächlich daran arbeitete, fand ich heraus, dass es nicht so entmutigend ist, wie es scheint.

Ich habe gerade ein System mit all diesen Funktionen in WENIGER ALS 2 STUNDEN gebaut!

Ich zeige Ihnen genau, wie Sie ein solches System von Grund auf entwerfen und implementieren können - und Sie werden erstaunt sein, wie einfach es 2025 mit modernen Werkzeugen und dem richtigen architektonischen Ansatz wirklich ist.

Der komplette Quellcode ist am Ende dieses Artikels verfügbar. Lassen Sie uns eintauchen!

Wir beginnen mit einem AI-Dokumentations-SaaS-Produkt namens DocuMind.

DocuMind ist ein AI-Dokumentations-SaaS-Produkt, das mit einem Multi-Tenant-Modell entwickelt wurde, um Einzelbenutzer, kleine Unternehmen und Großunternehmen zu unterstützen.

Die Plattform bietet leistungsstarke AI-Funktionen für das Dokumentenmanagement, einschließlich automatischer Erstellung von Zusammenfassungen, Ermittlung von Schlüsselpunkten und intelligenter Inhaltsvorschläge innerhalb von Organisationen.

Welche Funktionen sind für die SaaS-Authentifizierung und -Autorisierung erforderlich?#

Lassen Sie uns zunächst die notwendigen Anforderungen überprüfen. Welche Funktionen benötigen Sie?

Multi-Tenant-Architektur#

Um eine Multi-Tenant-Architektur zu ermöglichen, benötigen Sie eine Entitätsschicht namens Organisation. Stellen Sie sich vor, Sie haben einen einzigen Pool von Benutzern, die auf mehrere Arbeitsbereiche zugreifen können. Jede Organisation repräsentiert einen Arbeitsbereich, und Benutzer behalten eine einzige Identität bei, während sie basierend auf ihren zugewiesenen Rollen unterschiedliche Arbeitsbereiche (Organisationen) besuchen.

Es ist ein weit verbreitetes Merkmal bei Authentifizierungsanbietern. Eine Organisation in einem Identitätsmanagementsystem entspricht dem Arbeitsbereich, Projekt oder Mieter Ihrer SaaS-App.

Mitgliedschaft#

Ein Mitglied ist ein vorübergehendes Konzept, das verwendet wird, um den Mitgliedsstatus einer Identität innerhalb einer Organisation anzuzeigen.

Zum Beispiel meldet sich Sarah für Ihre App mit ihrer E-Mail an, [email protected]. Sie kann zu verschiedenen Arbeitsbereichen gehören. Wenn Sarah Teil von Arbeitsbereich A ist, aber nicht von Arbeitsbereich B, gilt sie als Mitglied von Arbeitsbereich A, aber nicht von Arbeitsbereich B.

Rollen- und Berechtigungsdesign#

In einer Multi-Tenant-Architektur benötigen Benutzer Rollen mit bestimmten Berechtigungen zum Zugriff auf ihre Ressourcen. Berechtigungen sind detaillierte Zugriffskontrollen, die bestimmte Aktionen definieren, wie lesen: bestellung oder schreiben: bestellung. Sie bestimmen, welche Aktionen auf bestimmten Ressourcen ausgeführt werden können.

Rollen sind eine Menge von Berechtigungen, die Mitgliedern in einer Multi-Tenant-Umgebung zugewiesen sind.

Sie müssen diese Rollen und Berechtigungen definieren, dann Rollen Benutzern zuweisen, und manchmal kann dies automatisierte Prozesse umfassen. Zum Beispiel:

1. Benutzer, die einer Organisation beitreten, haben automatisch die Mitgliedsrolle.
2. Der erste Benutzer, der einen Arbeitsbereich erstellt, wird automatisch der Admin-Rolle zugewiesen.

Anmelde- und Anmeldefluss#

Stellen Sie einen benutzerfreundlichen und sicheren Registrierungs- und Authentifizierungsprozess sicher, einschließlich grundlegender Anmelde- und Registrierungsoptionen:

1. E-Mail- und Passwort-Anmeldung: Traditionelle Anmeldemethode mit E-Mail und Passwort.
2. Passwortlose Anmeldung: Verwenden Sie E-Mail-Bestätigungscodes für einfachen und sicheren Zugriff.
3. Kontoverwaltung: Ein Konto-Center, in dem Benutzer ihre E-Mail, ihr Passwort und andere Details aktualisieren können.
4. Soziale Anmeldung: Optionen wie Google und GitHub für schnelles Anmelden.
5. Multi-Faktor-Authentifizierung (MFA): Verbesserung der Sicherheit durch die Zulassung der Anmeldung über Authenticator-Apps wie Duo.

Mietererstellung und Einladung#

In einer Multi-Tenant-SaaS-App ist ein entscheidender Unterschied im Benutzerfluss die Unterstützung der Mietererstellung und der Benutzereinladungen. Dieser Prozess erfordert sorgfältige Planung und Umsetzung, da er eine entscheidende Rolle für die Produktaktivierung und das Wachstum spielt.

Hier sind ein paar typische Nutzungsströme, die Sie berücksichtigen müssen:

Hier sind einige allgemeine Szenarien, die in fast jeder SaaS-App zu finden sind. Verwenden Sie diese als Referenz, um Ihr Produkt- und Design-Team zu inspirieren, und erstellen Sie nach Bedarf eigene Flows.

Technische Architektur und Systemdesign#

Sobald wir alle Produktanforderungen verstehen, gehen wir zur Implementierung über.

Authentifizierungsstrategie definieren#

Authentifizierung sieht beängstigend aus. Benutzer benötigen:

• E-Mail- und Passwort-Registrierung/Anmeldung
• Ein-Klick-Anmeldung mit Google/Github
• Passwortzurücksetzung, wenn sie es vergessen
• Team-weite Anmeldung für Unternehmenskunden
• ...

Allein die Implementierung dieser grundlegenden Funktionen könnte Wochen der Entwicklung dauern.

Aber jetzt müssen wir KEINES davon selbst bauen!

Moderne Auth-Anbieter (diesmal wähle ich Logto) haben all diese Funktionen für uns verpackt. Der Authentifizierungsfluss ist unkompliziert:

Von Wochen der Entwicklung zu 15 Minuten Einrichtung, Logto übernimmt alle komplexen Abläufe für uns! Wir werden die Integrationsschritte im Implementierungsteil später behandeln. Jetzt können wir uns darauf konzentrieren, die Kernfunktionen von DocuMind zu entwickeln!

Multi-Tenant-Architektur etablieren#

Das Organisationssystem ermöglicht es Benutzern, mehrere Organisationen zu erstellen und beizutreten. Lassen Sie uns die Kernbeziehungen verstehen:

In diesem System kann jeder Benutzer mehreren Organisationen angehören, und jede Organisation kann mehrere Mitglieder haben.

Zugriffskontrolle in der Multi-Tenant-App aktivieren#

Rollenbasierte Zugriffskontrolle (RBAC) ist wichtig, um Sicherheit und Skalierbarkeit in Multi-Tenant-SaaS-Anwendungen zu gewährleisten.

In einer Multi-Tenant-App ist das Design von Berechtigungen und Rollen normalerweise konsistent, da es aus dem Produktdesign stammt. Zum Beispiel gibt es in mehreren Arbeitsbereichen typischerweise eine Admin-Rolle und eine Mitgliedsrolle. Logto als Auth-Anbieter hat das folgende rollenbasierte Zugriffsteuerungs-Design auf Organisationsebene:

1. Einheitliche Berechtigungsdefinitionen: Berechtigungen werden auf Systemebene definiert und gelten konsistent in allen Organisationen, wodurch eine wartbare und konsistente Berechtigungsverwaltung gewährleistet wird
2. Organisationstemplates: Vordefinierte Rollen- und Berechtigungskombinationen durch Organisationstemplates, die die Initialisierung von Organisationen vereinfachen

Die Berechtigungsverhältnisse sehen folgendermaßen aus:

Da jeder Benutzer seine eigenen Rolle(n) innerhalb jeder Organisation benötigt, muss die Beziehung zwischen Rollen und Organisationen die Rollen widerspiegeln, die jedem Benutzer zugewiesen sind:

Wir haben das Organisationssystem und das Zugriffskontrollsystem entworfen, und jetzt können wir mit der Entwicklung unseres Produkts beginnen!

Technologiestack#

Ich habe einen anfängerfreundlichen, portablen Stack gewählt:

1. Frontend: React (leicht übertragbar auf Vue/Angular/Svelte)
2. Backend: Express (einfaches, intuitives API)

Warum Frontend und Backend trennen? Weil es eine klare Architektur hat, leicht zu erlernen und einfach zu wechseln ist. Und für Auth-Anbieter verwende ich Logto als Beispiel.

Und für die folgenden Anleitungen, ihre Muster funktionieren hier mit: jedem Frontend, jedem Backend und jedem Auth-System.

Grundlegenden Authentifizierungsfluss zu Ihrer App hinzufügen#

Dies ist der einfachste Schritt. Wir müssen Logto nur in unser Projekt integrieren. Dann können wir die Methoden zur Benutzeranmeldung/Registrierung im Logto-Konsole nach unseren Bedürfnissen konfigurieren.

Logto zu Ihrer App installieren#

Melden Sie sich zunächst bei Logto Cloud an. Sie können ein kostenloses Konto erstellen, wenn Sie noch keines haben. Erstellen Sie einen Entwicklungs-Mieter zum Testen.

Klicken Sie im Mieter-Konsole auf die Schaltfläche "Anwendung" auf der linken Seite. Wählen Sie dann React aus, um unsere Anwendung zu erstellen.

Folgen Sie der Anleitung auf der Seite. Sie können die Logto-Integration in etwa 5 Minuten abschließen!

Hier ist mein Integrationscode:

Hier ist ein nützlicher Trick: Unsere Anmeldeseite hat sowohl Anmelden- als auch Registrieren-Schaltflächen. Die Registrieren-Schaltfläche führt direkt zur Registrierungsseite von Logto. Dies funktioniert über Logtos erste Bildschirm Funktion. Sie bestimmt, welchen Schritt des Auth-Flusses die Benutzer zuerst sehen.

Sie können standardmäßig zur Registrierungsseite wechseln, wenn Ihr Produkt viele neue Benutzer erwartet.

Nach dem Klicken auf die Anmeldeschaltfläche gelangen Sie zur Logto-Anmeldeseite. Bei erfolgreicher Anmeldung (oder Registrierung) herzlichen Glückwunsch! Ihre App hat ihren ersten Benutzer (Sie)!

Und rufen Sie die signOut-Funktion des useLogto-Hooks auf, um den Benutzer bei Bedarf abzumelden.

Anmeldemethoden anpassen#

Klicken Sie in der Logto-Konsole im linken Menü auf "Anmeldeerlebnis". Klicken Sie dann auf die Registerkarte "Registrierung und Anmeldung". Auf dieser Seite folgen Sie den Anweisungen, um die Anmelde-/Registrierungsmethoden von Logto zu konfigurieren.

Und der Anmeldefluss sieht so aus:

Multi-Faktor-Authentifizierung aktivieren#

Mit Logto ist die MFA-Aktivierung einfach. Klicken Sie einfach auf die Schaltfläche "Multi-Faktor-Auth" in der Logto-Konsole. Aktivieren Sie es dann auf der Seite Multi-Faktor-Authentifizierung.

Und der MFA-Fluss sieht so aus:

Alles ist so einfach! Wir haben ein komplexes Benutzer-Authentifizierungssystem in nur wenigen Minuten eingerichtet!

Multi-Tenant-Organisationserlebnis hinzufügen#

Jetzt haben wir unseren ersten Benutzer! Allerdings gehört dieser Benutzer noch keiner Organisation an, und wir haben noch keine Organisationen erstellt.

Logto bietet integrierte Unterstützung für Multi-Tenancy. Sie können in Logto beliebig viele Organisationen erstellen. Jede Organisation kann mehrere Mitglieder haben.

Jeder Benutzer kann seine Organisationsinformationen von Logto abrufen. Dies ermöglicht die Unterstützung von Mandantenfähigkeit

Abrufen der Organisationsinformationen eines Benutzers#

Um die Organisationsinformationen eines Benutzers von Logto zu erhalten, folgen Sie diesen beiden Schritten:

Deklarieren Sie den Zugriff auf Organisationsinformationen in der Logto-Konfiguration. Dies wird durch das Festlegen der entsprechenden scopes und resources erledigt.

Verwenden Sie die fetchUserInfo-Methode von Logto, um Benutzerinformationen, einschließlich Organisationsdaten, abzurufen.

Nach Abschluss dieser Schritte müssen Sie sich abmelden und erneut anmelden. Dies ist notwendig, da wir den angeforderten Bereich und die Ressource geändert haben.

Im Moment haben Sie noch keine Organisationen erstellt. Der Benutzer hat auch keiner Organisation beigetreten. Das Dashboard zeigt "Sie haben noch keine Organisation".

Als nächstes erstellen wir eine Organisation für unsere Benutzer und fügen sie hinzu.

Dank Logto müssen wir keine komplexen Organisationsbeziehungen aufbauen. Wir müssen nur eine Organisation in Logto erstellen und Benutzer hinzufügen. Logto übernimmt für uns die gesamte Komplexität. Es gibt zwei Möglichkeiten, Organisationen zu erstellen:

1. Manuelle Erstellung von Organisationen über die Logto-Konsole
2. Verwenden der Logto-Management-API, um Organisationen zu erstellen, insbesondere bei der Gestaltung eines SaaS-Flows, der es Benutzern ermöglicht, ihre eigenen Organisationen (Arbeitsbereiche) zu erstellen.

Organisation in der Logto-Konsole erstellen#

Klicken Sie auf die Schaltfläche "Organisationen" im linken Bereich der Logto-Konsole. Erstellen Sie eine Organisation.

Jetzt haben Sie Ihre erste Organisation.

Fügen wir als nächstes den Benutzer zu dieser Organisation hinzu.

Gehen Sie zur Organisations-Detailseite. Wechseln Sie zur Registerkarte Mitglieder. Klicken Sie auf die Schaltfläche "+ Mitglied hinzufügen". Wählen Sie Ihren Anmeldungsbenutzer aus der linken Liste aus. Klicken Sie auf die Schaltfläche "Mitglied hinzufügen" unten rechts. Jetzt haben Sie den Benutzer erfolgreich zu dieser Organisation hinzugefügt.

Aktualisieren Sie Ihre APP-Seite. Sie werden sehen, dass der Benutzer jetzt einer Organisation angehört!

Selbstbedienungs-Organisationserstellungs-Erfahrung implementieren#

Die Erstellung einer Organisation in der Konsole ist nicht ausreichend. Ihre SaaS-App benötigt einen Flow, der es Endbenutzern ermöglicht, ihre eigenen Arbeitsbereiche einfach zu erstellen und zu verwalten. Verwenden Sie zur Implementierung dieser Funktionalität die Logto-Management-API.

Für Anleitungen, lesen Sie die Interagieren mit der Management-API-Dokumentation, um die API-Kommunikation mit Logto einzurichten.

Organisation Authentifizierungs-Interaktionsfluss verstehen#

Nehmen wir den Organisations-Erstellungsfluss als Beispiel. So funktioniert der Prozess der Organisationserstellung:

Dieser Fluss hat zwei wesentliche Authentifizierungsanforderungen:

1. Schutz des Backend-Service-API:
   • Der Zugriff des Frontends auf unsere Backend-Service-API erfordert Authentifizierung
   • Die API-Endpunkte sind durch Überprüfung des Logto-Zugriffstokens der Benutzer geschützt
   • Stellt sicher, dass nur authentifizierte Benutzer auf unsere Dienste zugreifen können
2. Zugriff auf Logto-Management-API:
   • Backend-Service muss die Logto-Management-API sicher aufrufen können
   • Befolgen Sie die Anleitung Mit der Management-API interagieren zur Einrichtung
   • Verwenden Sie die Machine-to-Machine-Authentifizierung, um Zugangsdaten zu erhalten

Ihre Backend-API schützen#

Erstellen wir zunächst einen API-Endpunkt in unserem Backend-Service zur Erstellung von Organisationen.

Unsere Backend-Service-API erlaubt nur authentifizierten Benutzern den Zugriff. Wir müssen Logto verwenden, um unsere API zu schützen. Wir müssen auch die aktuellen Benutzerinformationen kennen (wie Benutzer-ID).

Im Konzept von Logto (und OAuth 2.0) fungiert unser Backend-Service als Ressourcenserver. Benutzer greifen mit einem Zugangs-Token von Logto über das Frontend auf den DocuMind-Ressourcenserver zu. Der Ressourcenserver überprüft dieses Token. Wenn es gültig ist, gibt es die angeforderten Ressourcen zurück.

Lassen Sie uns eine API-Ressource erstellen, um unseren Backend-Service zu repräsentieren.

Gehen Sie zur Logto-Konsole.

1. Klicken Sie rechts auf die Schaltfläche "API-Ressourcen".
2. Klicken Sie auf "API-Ressource erstellen". Wählen Sie Express im Popup aus.
3. Füllen Sie "DocuMind API" als API-Name ein. Verwenden Sie "https://api.documind.com" als API-Identifier.
4. Klicken Sie auf Erstellen.

Keine Sorge um diese API-Identifier-URL. Es ist nur ein eindeutiger Identifier für Ihre API in Logto. Sie steht nicht in Zusammenhang mit der eigentlichen URL Ihres Backend-Services.

Sie sehen ein Tutorial zur Verwendung der API-Ressource. Sie können diesem Tutorial folgen oder unseren untenstehenden Schritten.

Lassen Sie uns einen requireAuth-Middleware erstellen, um unseren POST /organizations-Endpunkt zu schützen.

Verwenden Sie diesen Middleware in unserem POST /organizations-Endpunkt.

Dies schützt unseren POST /organizations-Endpunkt. Nur Benutzer mit gültigen Logto-Zugriffstoken können darauf zugreifen.

Wir können jetzt das Token von Logto in unserem Frontend erhalten. Benutzer können über diesen Token Organisationen über unseren Backend-Service erstellen. Der Middleware gibt uns auch die Benutzer-ID. Dies ist hilfreich beim Hinzufügen von Benutzern zu Organisationen.

Deklarieren Sie das API-Ressource-Identifikator im Logto-Konfigurationscode im Frontend. Fügen Sie den Identifikator zum Ressourcen-Array hinzu.

Wie zuvor, müssen sich Benutzer nach der Aktualisierung der Logto-Konfiguration erneut anmelden.

Im Dashboard erhalten Sie das Logto-Zugriffstoken, wenn Sie eine Organisation erstellen. Verwenden Sie dieses Token, um auf unsere Backend-Service-API zuzugreifen.

Jetzt können wir die DocuMind-Backend-Service-API ordnungsgemäß aufrufen.

Aufruf der Logto-Management-API#

Implementieren wir die Organisationserstellung mit der Logto-Management-API.

Wie bei Anfragen vom Frontend an den Backend-Service benötigen Anfragen des Backend-Services an Logto Zugriffstoken.

In Logto verwenden wir für die Zugriffstoken die Machine-to-Machine-Authentifizierung. Siehe Interagieren mit der Management-API.

Gehen Sie zur Anwendungsseite in der Logto-Console. Erstellen Sie eine Machine-to-Machine-Anwendung. Weisen Sie die Rolle "Zugriff auf die Logto-Management-API" zu. Kopieren Sie den Token-Endpunkt, die App-ID und das App-Geheimnis. Wir verwenden diese für Zugriffstoken.

Jetzt können wir Zugriffstoken für die Logto-Management-API über diese M2M-Anwendung erhalten.

Verwenden Sie dieses Zugriffstoken, um die Logto-Management-API aufzurufen.

Wir verwenden die folgenden Management-APIs:

• POST /api/organizations: Organisation erstellen (siehe: Organisation erstellen API-Referenz)
• POST /api/organizations/{id}/users: Benutzer zur Organisation hinzufügen (siehe: Benutzer hinzufügen API-Referenz)

Jetzt haben wir die Organisationserstellung über die Logto-Management-API implementiert. Wir können auch Benutzer zu Organisationen hinzufügen.

Lassen Sie uns diese Funktion im Dashboard testen.

und klicken Sie auf "Organisation erstellen"

Erstellung erfolgreich!

Der nächste Schritt besteht darin, Benutzer zu einer Organisation einzuladen. Wir werden diese Funktion in unserem Tutorial vorerst nicht implementieren. Sie wissen bereits, wie Sie die Management-API verwenden. Sie können dies als Produktdesignreferenz verwenden Mietererstellung und Einladung und diese Funktion leicht implementieren, indem Sie diesem Blog-Beitrag folgen: Wie wir Benutzerzusammenarbeit innerhalb einer Multi-Tenant-App implementieren.

Zugriffskontrolle zu Ihrer Multi-Tenant-App implementieren#

Jetzt lassen Sie uns zur Organisations-Zugriffskontrolle übergehen.

Wir wollen erreichen:

• Benutzer können nur auf Ressourcen zugreifen, die zu ihren eigenen Organisationen gehören: Dies kann durch Logto's organization token erfolgen
• Benutzer haben spezifische Rollen innerhalb von Organisationen (mit unterschiedlichen Berechtigungen) um autorisierte Aktionen durchzuführen: Dies kann durch Logtos Organisationstemplate-Funktion implementiert werden

Lassen Sie uns sehen, wie wir diese Funktionen implementieren können.

Verwendung des Logto-Organisationstokens#

Ähnlich wie beim Logto-Zugriffstoken, das wir früher erwähnt haben, gibt Logto ein Zugriffstoken aus, das einer spezifischen Ressource entspricht, und Benutzer verwenden dieses Token, um auf geschützte Ressourcen im Backend-Service zuzugreifen. Entsprechend gibt Logto ein Organisationstoken aus, das einer spezifischen Organisation entspricht, und Benutzer nutzen dieses Token, um auf geschützte Organisationsressourcen im Backend-Service zuzugreifen.

In der Frontend-Anwendung können wir die Methode getOrganizationToken von Logto verwenden, um ein Token für den Zugriff auf eine bestimmte Organisation zu erhalten.

Hier ist organizationId die ID der Organisation, der der Benutzer angehört.

Bevor Sie getOrganization oder jede Organisationsfunktion verwenden, müssen wir sicherstellen, dass urn:logto:scope:organizations-Bereich und urn:logto:resource:organization-Ressource in der Logto-Konfiguration enthalten sind. Da wir diese bereits früher deklariert haben, wiederholen wir dies nicht.

Auf unserer Organisationsseite verwenden wir das Organisationstoken, um Dokumente innerhalb der Organisation abzurufen.

Es gibt zwei wichtige Punkte in dieser Implementierung zu beachten:

1. Wenn die organizationId, die an getOrganizationToken übergeben wird, keine der aktuellen Benutzer gehörende Organisations-ID ist, kann diese Methode kein Token erhalten, wodurch sichergestellt wird, dass Benutzer nur auf ihre eigenen Organisationen zugreifen können.
2. Beim Anfordern von Organisationsressourcen verwenden wir das Organisationstoken anstelle des Zugriffstokens, weil wir für organisationsbezogene Ressourcen eher eine Organisation-Berechtigungskontrolle als eine Benutzer-Berechtigungskontrolle verwenden möchten (Sie werden dies besser verstehen, wenn wir die GET /documents-API später implementieren).

Als nächstes erstellen wir eine GET /documents-API in unserem Backend-Service. Ähnlich wie wir API-Ressource verwenden, um die POST /organizations-API zu schützen, verwenden wir organisationsspezifische Ressourcenindikatoren, um die GET /documents-API zu schützen.

Erstellen wir zunächst einen requireOrganizationAccess-Middleware, um Organisationsressourcen zu schützen.

Verwenden wir dann den requireOrganizationAccess-Middleware, um die GET /documents-API zu schützen.

Auf diese Weise haben wir die Verwendung von Organisationstokens zum Zugriff auf Organisationsressourcen implementiert. Im Backend-Service können Sie entsprechende Ressourcen aus der Datenbank basierend auf der Organisations-ID abrufen.

Einige Software erfordert eine Datenisolierung zwischen den Organisationen. Für weitere Diskussionen und Implementierungen können Sie den Blog-Beitrag lesen: Multi-Tenancy-Implementierung mit PostgreSQL: Lernen Sie anhand eines einfachen realistischen Beispiels.

Organisationenübergreifendes rollenbasiertes Zugriffskontroll-Design implementieren#

Wir haben die Verwendung von Organisationstokens zum Zugriff auf Organisationsressourcen implementiert. Als nächstes werden wir die Benutzerberechtigungskontrolle innerhalb von Organisationen mit RBAC implementieren.

Nehmen wir an, DocuMind hat zwei Rollen: Admin und Kollaborateur.

Admins können Dokumente erstellen und darauf zugreifen, während Kollaborateure nur auf Dokumente zugreifen können.

Unserer Organisation benötigen daher diese beiden Rollen: Admin und Kollaborateur.

Admin hat sowohl die Berechtigungen lesen:dokumente als auch erstellen:dokumente, während Kollaborateur nur die Berechtigung lesen:dokumente hat.

• Admin
  • lesen:dokumente
  • erstellen:dokumente
• Kollaborateur
  • lesen:dokumente

Hier kommt Logtos Organisationstemplate-Funktion ins Spiel.

Ein Organisationstemplate ist eine Vorlage des Zugriffskontrollmodells für jede Organisation: Es definiert die Rollen und Berechtigungen, die für alle Organisationen gelten.

Warum Organisationstempor?

Weil Skalierbarkeit eine der wichtigsten Anforderungen an SaaS-Produkte ist. Mit anderen Worten, was für einen Kunden funktioniert, sollte für alle Kunden funktionieren.

Gehen wir zur Logto-Console > Organisationen-Templates > Organisationen-Berechtigungen und erstellen wir zwei Berechtigungen: lesen:dokumente und erstellen:dokumente.

Dann gehen wir zum Register Organisationenrollen, um zwei Benutzerrollen zu erstellen: Admin und Kollaborateur, und weisen diesen Rollen die entsprechenden Berechtigungen zu.

Auf diese Weise haben wir ein rollenbasiertes Zugriffskontrollmodell für jede Organisation erstellt.

Als nächstes gehen wir zu unserer Organisationsdetailseite, um unseren Mitgliedern geeignete Rollen zuzuweisen.

Jetzt haben unsere Organisationsbenutzer Rollen! Diese Schritte können Sie über die Logto-Management-API erreichen:

Jetzt können wir die Benutzerberechtigungskontrolle durch Überprüfung ihrer Berechtigungen umsetzen.

In unserem Code müssen wir dafür sorgen, dass das Organisationstoken des Benutzers die Berechtigungsinformationen enthält und diese Berechtigungen dann im Backend überprüfen.

In der Logto-Konfiguration des Frontend-Codes müssen wir die Berechtigungen deklarieren, die Benutzer innerhalb der Organisation anfordern müssen. Lass uns lesen:dokumente und erstellen:dokumente zur scopes-Deklaration hinzufügen.

Wie gewohnt, melden Sie sich mit Ihrem Benutzer an, damit diese Konfigurationen wirksam werden.

Anschließend fügen wir im Backend die Berechtigungsüberprüfung zu unserem requireOrganizationAccess-Middleware hinzu.

Dann erstellen wir eine POST /documents API und verwenden den requireOrganizationAccess-Middleware mit RequiredScopes-Konfiguration, um diese API und die vorherige GET /documents-API zu schützen.

Auf diese Weise haben wir die Benutzerberechtigungskontrolle durch Überprüfung der Benutzerberechtigungen implementiert.

Im Frontend können Sie die Benutzerberechtigungsinformationen abrufen, indem Sie das Organisationstoken decodieren oder die Methode getOrganizationTokenClaims von Logto aufrufen.

Steuern Sie die Seitenelemente basierend auf Benutzerberechtigungen durch Überprüfen der Scopes in den Claims.

Weitere Funktionen zur Multi-Tenant-App hinzufügen#

Bisher haben wir die grundlegenden Benutzer- und Organisationsfunktionen in einem Multi-Tenant-SaaS-System implementiert! Es gibt jedoch immer noch einige Funktionen, die wir nicht abgedeckt haben, wie das Anpassen des Branding der Anmeldeseite für jede Organisation, das automatische Hinzufügen von Benutzern mit bestimmten Domain-E-Mails zu bestimmten Organisationen und die Integration von Unternehmens-SSO-Funktionalitäten.

Dies sind alle sofort einsatzbereite Funktionen, und Sie können weitere Informationen zu diesen Funktionen in der Logto-Dokumentation finden.

Zusammenfassung#

Erinnern Sie sich, wie überwältigend es sich am Anfang anfühlte? Benutzer, Organisationen, Berechtigungen, Unternehmensfunktionen... es schien wie ein endloser Berg, den es zu besteigen galt.

Aber sehen Sie, was wir erreicht haben:

• Ein vollständiges Authentifizierungssystem mit verschiedenen Anmeldeoptionen und MFA-Unterstützung
• Ein flexibles Organisationssystem, das mehrere Mitgliedschaften unterstützt
• Rollenbasierte Zugriffskontrolle innerhalb von Organisationen

Und das Beste daran? Wir mussten das Rad nicht neu erfinden. Indem wir moderne Werkzeuge wie Logto nutzten, verwandelten wir, was Monate der Entwicklung hätte dauern können, in eine Angelegenheit von Stunden.

Der vollständige Quellcode für dieses Tutorial ist verfügbar unter: Multi-Tenant-SaaS-Beispiel.

Dies ist die Kraft der modernen Entwicklung im Jahr 2025 - wir können uns auf den Aufbau einzigartiger Produktmerkmale konzentrieren, anstatt mit Infrastruktur zu kämpfen. Jetzt liegt es an Ihnen, etwas Erstaunliches zu bauen!

Erkunden Sie alle Funktionen von Logto, von Logto Cloud bis Logto OSS, auf der Logto-Website oder melden Sie sich Logto Cloud noch heute an.