Untergeordnete Seiten
  • Crowd Dokumentation - Integration von AppFuse
Zum Ende der Metadaten springen
Zum Anfang der Metadaten


AppFuse bietet einen guten Startpunkt für die Entwicklung von Web-Applikationen. Sie wählen die Frameworks aus und AppFuse generiert das Applikations-Gerüst.

Im Kern stützt sich die Web-Security der AppFuse 2.0.2+ Applikationen auf das modulare und erweiterbare Spring Security Authentifizierungs-Framework. In diesem Tutorial konzentrieren wir uns auf die grundlegende Integration von Crowd in Spring Security, mithilfe einer von AppFuse generierten Applikation.


Spring Security war früher als Acegi bekannt.

  • Das Acegi Security Framework wurde im 2.0 Release zu Spring Security.
  • Appfuse 2.0.2 wechselte für die Authentifizierung von Acegi zu Spring Security. Frühere Versionen von Appfuse verwenden Acegi.
  • Es gibt ein separates Tutorial für Sie auf Englisch, wenn Sie mit in einer früheren Version von Appfuse mit Acegi arbeiten.
  • Crowd 1.6 und höher unterstützt Spring Security sowie Acegi. Frühere Versionen von Crowd unterstützen nur Acegi.
  • Wir empfehlen, dass alle neuen Projekte Spring Security verwenden, da es aktiv gewartet wird.


Grundvoraussetzungen

Dieses Tutorial setzt voraus, dass Sie Crowd 1.6 und neuer installiert haben und Appfuse 2.0.2 oder neuer verwenden.


Schritt 1: Beschaffen Sie AppFuse

In diesem Tutorial werden wir den Struts2-basic Archetyp für die Erstellung des Projekts verwenden, aber die anderen Typen sollten gleich sein. Konsultieren Sie für weitere Informationen die AppFuse Schnellstart-Anleitung (auf Englisch). Dort werden insbesondere die Datenbank-Anforderungen für AppFuse beschrieben.

  1. Erstellen Sie das Projekt.

    mvn archetype:create -DarchetypeGroupId=org.appfuse.archetypes \
    -DarchetypeArtifactId=appfuse-basic-struts \
    -DremoteRepositories=http://static.appfuse.org/releases -DarchetypeVersion=2.0.2 \
    -DgroupId=com.mycompany.app -DartifactId=myproject
  2. Da wir die Kern Spring Security Konfiguration editieren werden, benötigen wir den ganzen Quellcode der Applikation.

    cd myproject
    mvn appfuse:full-source
  3. Erstellen Sie es.

    mvn clean install
  4. Starten Sie es.

    mvn jetty:run-war -Dmaven.test.skip
  5. Spielen Sie damit.

    http://localhost:8080/
  6. Fahren Sie es herunter.

    ctrl+c


Schritt 2: Fügen Sie AppFuse als Applikation hinzu

Fügen Sie Appfuse als Applikation über die Crowd-Konsole hinzu. Lesen Sie für weitere Informationen darüber die Dokumentation über das Hinzufügen einer Applikation.


Schritt 3: Fügen Sie den Crowd Spring Security Konnektor zu AppFuse hinzu

Öffnen Sie die pom.xml und fügen Sie die Crowd Client-Libraries als Projekt-Abhängigkeiten hinzu:

<dependencies>
  <dependency>
    <groupId>com.atlassian.crowd</groupId>
    <artifactId>crowd-integration-client</artifactId>
    <version>1.6</version>
  </dependency>
...
</dependencies>

Sie müssen außerdem noch die Datei myproject/src/main/resources/crowd.properties erstellen:

application.name                        appfuse
application.password                    password
application.login.url                   http://localhost:8095/crowd/
crowd.server.url                        http://localhost:8095/crowd/services/
session.isauthenticated                 session.isauthenticated
session.tokenkey                        session.tokenkey
session.validationinterval              0
session.lastvalidation                  session.lastvalidation

Besonders der Applikationsname und das Passwort müssen mit den Werten, die beim Hinzufügen der Applikation definiert wurden, übereinstimmen (Sehen Sie Schritt 2).

Kopieren Sie schließlich die STANDALONE/client/conf/crowd-ehcache.xml zu myproject/src/main/resources/crowd-ehcache.xml herüber. Diese Datei definiert die Cache-Einstellungen, wie die Cache-Timeouts, die beim Zugriff der Daten vom Crowd Server verwendet werden.


Schritt 4: Verbinden Sie die zentralisierte Authentifizierung

Bevor Sie die Sicherheitskonfiguration modifizieren, müssen Sie die Spring Konfigurationsdatei hinzufügen, um die Crowd Client-Beans zu verbinden. Fügen Sie die applicationContext-CrowdClient.xml Konfigurationsdatei zu der Liste der contextConfigLocations in myproject/src/main/webapp/WEB-INF/web.xml hinzu:

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath:/applicationContext-resources.xml
        classpath:/applicationContext-dao.xml
        classpath:/applicationContext-service.xml
        classpath*:/applicationContext.xml
        classpath:/applicationContext-CrowdClient.xml
        /WEB-INF/applicationContext*.xml
        /WEB-INF/xfire-servlet.xml
        /WEB-INF/security.xml
    </param-value>
</context-param>

AppFuse speichert alle Spring Security Konfigurationen ordentlich in der myproject/src/main/webapp/WEB-INF/security.xml. Um die zentralisierte Authentifizierung zu erhalten, müssen wir die Spring Security für die Verwendung der Crowd-Komponenten einrichten, um die Benutzerinformationen zu beziehen. Editieren Sie die Beans in der security.xml:

  1. Fügen Sie die Definition des CrowdUserDetailsService hinzu:

    <beans:bean id="crowdUserDetailsService" class="com.atlassian.crowd.integration.springsecurity.user.CrowdUserDetailsServiceImpl">
            <beans:property name="authenticationManager" ref="crowdAuthenticationManager"/>
            <beans:property name="groupMembershipManager" ref="crowdGroupMembershipManager"/>
            <beans:property name="userManager" ref="crowdUserManager"/>
            <beans:property name="authorityPrefix" value="ROLE_"/>
    </beans:bean>
  2. Fügen Sie die Definition des RemoteCrowdAuthenticationProvider hinzu, der die Spring Security Authentifizierungsanfragen zu Crowd delegiert:

    <beans:bean id="crowdAuthenticationProvider" class="com.atlassian.crowd.integration.springsecurity.RemoteCrowdAuthenticationProvider">
    	<custom-authentication-provider />
    	<beans:constructor-arg ref="crowdAuthenticationManager"/>
            <beans:constructor-arg ref="httpAuthenticator"/>
            <beans:constructor-arg ref="crowdUserDetailsService"/>
    </beans:bean>
  3. Kommentieren Sie den Standard Authentifizierungsanbieter aus, da wir ihn mit Crowd ersetzt haben:

    <!--
        <authentication-provider user-service-ref="userDao">
            <password-encoder ref="passwordEncoder"/>
        </authentication-provider>
    -->
  4. Nun führen Sie folgendes aus:

    mvn clean install

    Dadurch werden die Konfigurationsänderungen übernommen und die Crowd Client-Library zu Ihrer App hinzugefügt. Starten Sie danach folgendes:

    mvn jetty:run-war -Dmaven.test.skip
  5. Wechseln Sie zu http://localhost:8080/.
    Sie sollten nun in der Lage sein die Benutzer in Ihrem Crowd-Repository zu authentifizieren, die die folgenden Bedingungen erfüllen:


Glückwunsch! Sie haben nun die zentralisierte Authentifizierung(Lächeln)


Zentralisierte Benutzerverwaltung auf Applikationsebene

Eine Eigenart, die Sie vielleicht bemerkt haben, ist, dass Sie nicht die Profildetails eines Benutzers ansehen können, der in Crowd existiert, aber vor der Crowd-Integration nicht in AppFuse existierte. Obwohl es möglich ist einen Crowd-Benutzer, z. B. namens "dude", zu authentifizieren und AppFuse als "dude" zu benutzen, ist "dude" nicht in AppFuses lokalen Datenbank. AppFuse nutzt ein Datenbank-gestütztes Benutzerverwaltungssystem. Um eine zentralisierte Benutzerverwaltung auf Applikationsebene zu erreichen, muss AppFuse seine Aufrufe für die Erstellung, Beziehung und Aktualisierung der Benutzer, unter Verwendung der Crowd Remote-API (Dokumentation auf Englisch), zu Crowd delegieren. Dies vermeidet Datenredundanz und eliminiert lästige Datensynchronisierungen. Dieses Thema geht über dieses kurzes Tutorial hinaus.


Schritt 5: Binden Sie das Single Sign-On ein

Die Aktivierung des Single Sign-Ons (SSO) erfordert eine kleine Anpassung der security.xml:

  1. Entfernen Sie die Standards vom <http/> Element:
    1. Entfernen Sie die auto-config Attribute und fügen Sie ein entry-pont-ref="crowdAuthenticationProcessingFilterEntryPoint" Attribut zu dem Http-Element hinzu.
    2. Entfernen Sie das <form-login> Element.
      Sie sollten ein ähnliches Http-Element vorliegen haben, wie dieses:

      <http lowercase-comparisons="false" entry-point-ref="crowdAuthenticationProcessingFilterEntryPoint"> <!-- note: no auto-config attribute! -->
          <!--intercept-url pattern="/images/*" filters="none"/>
          <intercept-url pattern="/styles/*" filters="none"/>
          <intercept-url pattern="/scripts/*" filters="none"/-->
          <intercept-url pattern="/admin/*" access="ROLE_ADMIN"/>
          <intercept-url pattern="/passwordHint.html*" access="ROLE_ANONYMOUS,ROLE_ADMIN,ROLE_USER"/>
          <intercept-url pattern="/signup.html*" access="ROLE_ANONYMOUS,ROLE_ADMIN,ROLE_USER"/>
          <intercept-url pattern="/a4j.res/*.html*" access="ROLE_ANONYMOUS,ROLE_ADMIN,ROLE_USER"/>
          <!-- APF-737, OK to remove line below if you're not using JSF -->
          <intercept-url pattern="/**/*.html*" access="ROLE_ADMIN,ROLE_USER"/>
      <!--  <form-login login-page="/login.jsp" authentication-failure-url="/login.jsp?error=true" login-processing-url="/j_security_check"/> -->
          <remember-me user-service-ref="userDao" key="e37f4b31-0c45-11dd-bd0b-0800200c9a66"/>
      </http>
  2. Ändern Sie den Standard Bearbeitungsfilter zu Crowds SSO-Filter, indem Sie die folgenden Bean-Definitionen hinzufügen:

    <authentication-manager alias="authenticationManager"/>
     
    <beans:bean id="crowdAuthenticationProcessingFilterEntryPoint" class="org.springframework.security.ui.webapp.AuthenticationProcessingFilterEntryPoint">
    	<beans:property name="loginFormUrl" value="/login.jsp"/>
    </beans:bean>
    	
    <beans:bean id="crowdAuthenticationProcessingFilter" class="com.atlassian.crowd.integration.springsecurity.CrowdSSOAuthenticationProcessingFilter">
        <custom-filter position="AUTHENTICATION_PROCESSING_FILTER"/>       
        <beans:property name="httpAuthenticator" ref="httpAuthenticator"/>
        <beans:property name="authenticationManager" ref="authenticationManager"/>
        <beans:property name="authenticationFailureUrl" value="/login.jsp?error=true"/>
        <beans:property name="defaultTargetUrl" value="/"/>
        <beans:property name="filterProcessesUrl" value="/j_security_check"/>
    </beans:bean>
  3. Fügen Sie die Definition des CrowdLogoutHandler hinzu und inkludieren Sie einen LogoutFilter, der ihn referenziert:

    <beans:bean id="crowdLogoutHandler" class="com.atlassian.crowd.integration.springsecurity.CrowdLogoutHandler">
        <beans:property name="httpAuthenticator" ref="httpAuthenticator"/>
    </beans:bean>
    
    <beans:bean id="logoutFilter" class="org.springframework.security.ui.logout.LogoutFilter">
        <custom-filter position="LOGOUT_FILTER"/>
        <beans:constructor-arg value="/index.jsp"/>
        <beans:constructor-arg>
            <beans:list>
                <beans:ref bean="crowdLogoutHandler"/>
                <beans:bean class="org.springframework.security.ui.logout.SecurityContextLogoutHandler"/>
            </beans:list>
        </beans:constructor-arg>
        <beans:property name="filterProcessesUrl" value="/logout.jsp"/>
    </beans:bean>
  4. Nun wiederholen Sie folgendes:

    mvn jetty:run-war -Dmaven.test.skip=true

Das SSO wird nur für Benutzer funktionieren, die sich bei beiden Applikationen authentifizieren können und autorisiert sind die Applikationen zu verwenden. Probieren Sie folgendes aus:

  • Loggen Sie sich in Crowd ein - Sie sollten in AppFuse eingeloggt sein.
  • Loggen Sie sich aus AppFuse aus - Sie sollten aus Crowd ausgeloggt sein.
  • Loggen Sie sich in AppFuse ein, loggen Sie sich aus Crowd aus, loggen Sie sich als anderer Benutzer in Crowd ein und aktualisieren Sie AppFuse - Sie sollten als der neue Benutzer eingeloggt sein.

Glückwunsch, Sie haben SSO. (Lächeln)




Crowd Dokumentation Übersicht:




Crowd Doku

  • Keine Stichwörter