Keycloak und Spring Boot: Der ultimative Leitfaden zur Implementierung von Single Sign-On

Einführung:

Single Sign-On (SSO) ist zu einem wesentlichen Merkmal moderner Webanwendungen geworden und verbessert sowohl das Benutzererlebnis als auch die Sicherheit. Dieser umfassende Leitfaden führt Sie durch die Implementierung von SSO mit Keycloak und Spring Boot und bietet eine robuste Authentifizierungs- und Autorisierungslösung für Ihre Anwendungen.

Bedeutung von SSO mit Keycloak

Single Sign-On (SSO) ist für die Rationalisierung von Authentifizierungsprozessen, die Erhöhung der Sicherheit und die Verbesserung der Benutzererfahrung unerlässlich. Hier sind einige der wichtigsten Vorteile:

1. Zentralisierte Authentifizierung: SSO ermöglicht Benutzern die einmalige Authentifizierung und den Zugriff auf mehrere Anwendungen. Keycloak bietet eine zentrale Verwaltung für Benutzeridentitäten, was in Umgebungen mit zahlreichen Anwendungen nützlich ist.

2. Verbesserte Sicherheit: Mit zentraler Identitätsverwaltung können Sicherheitsrichtlinien (wie Passwortstärke, Zwei-Faktor-Authentifizierung und Richtlinien zur Kontosperrung) einheitlich durchgesetzt werden. Die Unterstützung von Keycloak für Protokolle wie OpenID Connect und OAuth 2.0 sorgt für robuste, moderne Sicherheitsstandards.

3. Reduzierte Passwortmüdigkeit und verbesserte Benutzererfahrung: Durch die einmalige Anmeldung vermeiden Benutzer Passwortmüdigkeit und mehrfache Anmeldeinformationen, was zu reibungsloseren und schnelleren Interaktionen zwischen Anwendungen führt.

4. Skalierbarkeit und Flexibilität: Die Konfiguration von Keycloak kann eine große Anzahl von Benutzern und mehrere Identitätsanbieter unterstützen, einschließlich sozialer Anmeldungen (Google, Facebook usw.) und Unternehmensverzeichnissen (LDAP, Active Directory).

5. Anpassung und Erweiterbarkeit: Keycloak ermöglicht benutzerdefinierte Designs, Anmeldeabläufe und Erweiterungen und ist somit an verschiedene Anforderungen anpassbar. Es ist außerdem Open Source und bietet Organisationen die Flexibilität, die Plattform nach Bedarf zu ändern oder zu erweitern.
   Alternativen zu Single Sign-On (SSO):

6. Mehrfachanmeldung / traditionelle Authentifizierung:

   • Benutzer haben separate Anmeldeinformationen für jede Anwendung oder jeden Dienst
   • Erfordert eine individuelle Anmeldung bei jedem System
   • Jede Anwendung verwaltet ihre eigene Authentifizierung

7. Verbundidentität:

   • Ähnlich wie SSO, ermöglicht jedoch die Authentifizierung über verschiedene Organisationen hinweg
   • Verwendet Standards wie SAML oder OpenID Connect
   • Die Identität des Benutzers wird von seiner Heimatorganisation überprüft

8. Multi-Faktor-Authentifizierung (MFA):

   • Fügt über Benutzername und Passwort hinaus zusätzliche Sicherheitsebenen hinzu
   • Kann zusammen mit SSO oder herkömmlicher Authentifizierung verwendet werden
   • In der Regel handelt es sich um etwas, das Sie wissen, haben und sind

Erläuterung des SSO-Ablaufs:

Bevor wir uns mit der Implementierung befassen, sollten wir uns mit dem SSO-Ablauf befassen:

Voraussetzungen:

• Java 17 oder höher
• Maven
• Docker (zum Ausführen von Keycloak)

Schritt 1: Projekteinrichtung

Erstellen Sie ein neues Spring Boot-Projekt mit der folgenden Struktur:

keycloak-demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── bansikah/
│   │   │           └── keycloakdemo/
│   │   │               ├── config/
│   │   │               │   └── SecurityConfig.java
│   │   │               ├── controller/
│   │   │               │   └── FoodOrderingController.java
│   │   │               └── KeycloakDemoApplication.java
│   │   └── resources/
│   │       ├── templates/
│   │       │   ├── home.html
│   │       │   └── menu.html
│   │       └── application.yml
├── docker-compose.yml
└── pom.xml

Hinweis:

Bansikah ist mein Name? So können Sie Ihr eigenes oder Beispiel setzen, was Sie wollen...

Schritt 2: Konfigurieren Sie pom.xml

Fügen Sie die folgenden Abhängigkeiten zu Ihrer pom.xml hinzu oder ersetzen Sie einfach den Abhängigkeitsabschnitt, um Konflikte zu vermeiden:

<dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-security</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-oauth2-client</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-oauth2-resource-server</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-thymeleaf</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.thymeleaf.extras/thymeleaf-extras-springsecurity3 -->
        <dependency>
            <groupid>org.thymeleaf.extras</groupid>
            <artifactid>thymeleaf-extras-springsecurity3</artifactid>
            <version>3.0.5.RELEASE</version>
        </dependency>
    </dependencies>

Schritt 3: Keycloak mit Docker einrichten

Erstellen Sie eine docker-compose.yml-Datei im Stammverzeichnis:

version: '3'

services:
  keycloak:
    image: quay.io/keycloak/keycloak:latest
    environment:
      KEYCLOAK_ADMIN: admin
      KEYCLOAK_ADMIN_PASSWORD: admin
    ports:
      - "8088:8080"
    command:
      - start-dev

  app:
    build: .
    ports:
      - "8082:8082"
    depends_on:
      - keycloak

Führen Sie den Keycloak-Server aus mit:

docker-compose up -d

Schritt 4: Keycloak konfigurieren

1. Zugriff auf die Keycloak-Administratorkonsole:

   • Gehen Sie zu http://localhost:8088
   • Melden Sie sich mit admin/admin als Benutzername und Passwort an

2. Erstellen Sie ein neues Reich:

   • Gehen Sie oben links auf „Master“
   • Wählen Sie „Bereich hinzufügen“
   • Nennen Sie es „Food-Ordering-Reich“.
   • Klicken Sie auf „Erstellen“

3. Neuen Kunden erstellen:
   Auf dem ersten Bildschirm:

   • Setzen Sie die „Client-ID“ auf „food-ordering-client“
   • Client-Typ: Wählen Sie „OpenID Connect“
   • Klicken Sie auf „Weiter“

Auf dem nächsten Bildschirm (Funktionskonfiguration):

• Client-Authentifizierung: Aktivieren Sie diese Option (dies ersetzt die alte Einstellung „vertraulich“)
• Autorisierung: Sie können diese Option deaktiviert lassen, es sei denn, Sie benötigen eine detaillierte Autorisierung
• Klicken Sie auf „Weiter“

1. Client-Konfiguration:
   • Setzen Sie die Root-URL auf http://localhost:8082/
   • Zugriffstyp auf vertraulich setzen
   • Fügen Sie gültige Weiterleitungs-URIs hinzu (jede URI in einer neuen Zeile):

 http://localhost:8082/
 http://localhost:8082/menu
 http://localhost:8082/login/oauth2/code/keycloak

• Webursprünge festlegen: http://localhost:8082
• Klicken Sie auf „Speichern“

1. Kundengeheimnis abrufen:
   • Gehen Sie zur Registerkarte „Anmeldeinformationen“
   • Kopieren Sie den Wert des Felds „Geheimnis“ zur Verwendung in der Anwendungskonfiguration

1. Erstellen Sie einen Benutzer:
   • Gehen Sie zu Benutzer und klicken Sie auf „Benutzer hinzufügen“
   • Legen Sie einen Benutzernamen fest (z. B. Testbenutzer)
   • Auf der Registerkarte „Anmeldeinformationen“:
     • Passwort festlegen
     • Deaktivieren Sie „Vorübergehend“

und legen Sie das Passwort fest:

Schritt 5: Konfigurieren Sie die Spring Boot-Anwendung

Erstellen Sie application.yml in src/main/resources:

keycloak-demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── bansikah/
│   │   │           └── keycloakdemo/
│   │   │               ├── config/
│   │   │               │   └── SecurityConfig.java
│   │   │               ├── controller/
│   │   │               │   └── FoodOrderingController.java
│   │   │               └── KeycloakDemoApplication.java
│   │   └── resources/
│   │       ├── templates/
│   │       │   ├── home.html
│   │       │   └── menu.html
│   │       └── application.yml
├── docker-compose.yml
└── pom.xml

Ersetzen Sie mit dem kopierten Geheimnis von Keycloak, normalerweise einem zufälligen Text.
Hinweis:

In der Produktion oder als gute Praxis empfiehlt es sich, vertrauliche Informationen als solche in einer .env-Datei im Stammverzeichnis Ihres Projekts aufzubewahren und sie als Variable in Ihrer Konfiguration zu verwenden. Dies wird etwa ${CLIENT_SECRET} sein wählt es aus der .env-Datei aus, wenn Sie Ihre Anwendung starten. Dies gilt auch für die Umleitung, die Issuer-URI und den Rest.

Schritt 6: Sicherheitskonfiguration erstellen

Erstellen Sie SecurityConfig.java in src/main/java/com/bansikah/keycloakdemo/config:

<dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-security</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-oauth2-client</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-oauth2-resource-server</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-thymeleaf</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.thymeleaf.extras/thymeleaf-extras-springsecurity3 -->
        <dependency>
            <groupid>org.thymeleaf.extras</groupid>
            <artifactid>thymeleaf-extras-springsecurity3</artifactid>
            <version>3.0.5.RELEASE</version>
        </dependency>
    </dependencies>

Schritt 7: Controller erstellen

Erstellen Sie FoodOrderingController.java in src/main/java/com/bansikah/keycloakdemo/controller:

version: '3'

services:
  keycloak:
    image: quay.io/keycloak/keycloak:latest
    environment:
      KEYCLOAK_ADMIN: admin
      KEYCLOAK_ADMIN_PASSWORD: admin
    ports:
      - "8088:8080"
    command:
      - start-dev

  app:
    build: .
    ports:
      - "8082:8082"
    depends_on:
      - keycloak

Schritt 8: HTML-Vorlagen erstellen

Erstellen Sie home.html in src/main/resources/templates:

docker-compose up -d

Menü.html in src/main/resources/templates erstellen:

 http://localhost:8082/
 http://localhost:8082/menu
 http://localhost:8082/login/oauth2/code/keycloak

Schritt 9: Führen Sie die Anwendung aus

Sie sollten über diese URL http://localhost:8082 auf die Anwendung zugreifen können und Folgendes sehen

und wenn Sie auf den Link hier klicken, gelangen Sie zum Keycloak-Formular, wo sich der Benutzer mit Benutzername und Passwort im Foodorder-Bereich authentifizieren muss

und nach der Authentifizierung sehen Sie die Menüseite

Angesichts der Bedeutung von SSO muss ich mich, selbst wenn ich mich abmelde, nicht erneut wie unten beschrieben anmelden

Dann kann ich erneut auf den Link klicken und werde nicht dazu aufgefordert, mein Passwort und meinen Benutzernamen wie folgt erneut einzugeben

Abschluss

Herzlichen Glückwunsch? Und vielen Dank, dass Sie bis zu diesem Zeitpunkt weitergemacht haben
Diese Implementierung demonstriert eine robuste SSO-Lösung mit Keycloak und Spring Boot. Es bietet ein nahtloses Authentifizierungserlebnis bei gleichzeitiger Wahrung der Sicherheit. Die Konfiguration ermöglicht eine einfache Anpassung und Erweiterung, um spezifische Anwendungsanforderungen zu erfüllen.
Wenn Sie auf Probleme stoßen oder Fragen zu dieser Implementierung haben, hinterlassen Sie bitte unten einen Kommentar. Denken Sie daran, die Dokumentation zu Spring Security und Keycloak für erweiterte Konfigurationen und Funktionen zu lesen.
Link zum Code auf Github

Ref:

• Frühlingsstiefel
• KeyCloak
• Java 17
• Maven
• Docker

Das obige ist der detaillierte Inhalt vonKeycloak und Spring Boot: Der ultimative Leitfaden zur Implementierung von Single Sign-On. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!