Installation

Mise en place de Tomcat

Nous installons le Java Development Kit 1.5

/usr/bin/apt-get install sun-java5-jdk sun-java5-fonts

Et nous le déclarons comme machine virtuelle Java par défaut:

/usr/sbin/update-java-alternatives --set java-1.5.0-sun

Installer Tomcat 5:

/usr/bin/apt-get install tomcat5

Désactivez le gestionnaire de sécurité Java de Tomcat, car il nuit au bon fonctionnement de CAS:

/bin/sed -i -e 's/^[#]*\(TOMCAT5_SECURITY=\).*$/\1no/' \
         /etc/default/tomcat5

Installation de Maven

Maven est un outil de gestion de projet Java nécessaire à la compilation de CAS.

Renseignez la version de Maven que vous souhaitez installer:

VERSION=2.0.9

Nous téléchargeons les binaires:

/usr/bin/wget http://apache.miroir-francais.fr/maven/binaries/apache-maven-2.0.9-bin.tar.gz \
    --output-document=/tmp/apache-maven-${VERSION}-bin.tar.gz

Nous décompressons l'archive que nous venons de télécharger:

/bin/tar --directory /tmp -xzf /tmp/apache-maven-${VERSION}-bin.tar.gz

Nous déplaçons le dossier ainsi créé à l'emplacement adéquat:

/bin/mv /tmp/apache-maven-${VERSION} /usr/local/apache-maven

Nous plaçons des liens symboliques vers les exécutables de Maven:

/bin/ln -s /usr/local/apache-maven/bin/m2 /usr/local/bin/m2
/bin/ln -s /usr/local/apache-maven/bin/mvn /usr/local/bin/mvn
/bin/ln -s /usr/local/apache-maven/bin/mvnDebug /usr/local/bin/mvnDebug

Mise en place du serveur CAS

En premier lieu, renseignez le numéro de la version que vous souhaitez installer:

VERSION=3.3

Téléchargez les sources de ce logiciel:

/usr/bin/wget http://www.ja-sig.org/downloads/cas/cas-server-${VERSION}-release.tar.gz \
    --output-document=/tmp/cas-server-${VERSION}-release.tar.gz

Décompressez les:

/bin/tar --directory /usr/src -xzf /tmp/cas-server-${VERSION}-release.tar.gz

Une fois ceci fait, placez le WAR de démo du serveur CAS dans le dossier des applications de Tomcat:

/bin/cp /usr/src/cas-server-${VERSION}/modules/cas-server-webapp-${VERSION}.war /var/lib/tomcat5/webapps/cas.war

Et redémarrez Tomcat5:

/etc/init.d/tomcat5 restart

Vous pouvez maintenant accéder à votre installation de démo du serveur CAS à l'adresse:

http://localhost:8180/cas/login

Pour tester votre installation, saisissez un identifiant quelconque, avec pour mot de passe la même valeur. Exemple:

• Identifiant: admin
• Mot de passe: admin
  

Identification basée sur un serveur MySQL

Nous allons voir ici comment configurer CAS de façon à rechercher les informations d'identification des utilisateurs dans une base de données MySQL.

Installation du connecteur JDBC MySQL

En premier lieu, renseignez la version du connecteur que vous souhaitez installer:

VERSION=5.1.6

Téléchargez les sources:

/usr/bin/wget http://mirrors.ircam.fr/pub/mysql/Downloads/Connector-J/mysql-connector-java-${VERSION}.tar.gz \
    --output-document=/tmp/mysql-connector-java-${VERSION}.tar.gz

Et décompressez les:

/bin/tar --directory /tmp -xzf /tmp/mysql-connector-java-${VERSION}.tar.gz

/bin/cp /tmp/mysql-connector-java-${VERSION}/mysql-connector-java-${VERSION}-bin.jar /var/lib/tomcat5/shared/lib/

Création d'une base de données (optionnel)

En premier lieu, vous devez installer un serveur MySQL. Pour ce faire, vous pouvez suivre mon guide MySQL sur Debian 4.0 Etch.

Une fois ceci fait, créez une base de données CAS (vous pouvez aussi le faire en suivant mon guide MySQL sur Debian 4.0 Etch).

Remarque: Si vous n'avez pas suivi mon guide pour créer la base de données, veuillez renseigner les paramètres de connexion au serveur MySQL:

MYSQL_HOST=localhost
MYSQL_DB=CAS
MYSQL_USERNAME=cas
MYSQL_USERPWD=password

Une fois la base de donnée créée, nous reprenons le court normal des choses. En premier lieu, nous plaçons une valeur par défaut pour le nom d'hôte du serveur de la base de données:

if [ -z "$MYSQL_HOST" ]; then
  MYSQL_HOST=localhost
fi

Nous créons la table des utilisateurs:

/bin/echo "CREATE TABLE user
(
    id INTEGER  NOT NULL AUTO_INCREMENT,
    login VARCHAR(255)  NOT NULL,
    password VARCHAR(255)  NOT NULL,
    PRIMARY KEY (id),
    UNIQUE INDEX unique_login (login)
)Type=InnoDB;" \
  | /usr/bin/mysql --user=$MYSQL_USERNAME \
    --password=$MYSQL_USERPWD --host=$MYSQL_HOST $MYSQL_DB

Une fois ceci fait, nous insérons le premier utilisateur:

/bin/echo "INSERT INTO user (login, password) VALUES ('admin', 'test');" \
  | /usr/bin/mysql --user=$MYSQL_USERNAME \
    --password=$MYSQL_USERPWD --host=$MYSQL_HOST $MYSQL_DB

Si vous connaissez la syntaxe SQL, vous pouvez voir que nous venons de créer un utilisateur avec les paramètres d'identification suivants:

• Identifiant: admin
• Mot de passe: test

Configuration de CAS pour utiliser une base de données MySQL

En premier lieu, placez-vous dans le dossier contenant les sources de la webapp CAS:

cd /usr/src/cas-server-${VERSION}/cas-server-webapp

Une fois ceci fait, nous créons une copie de sauvegarde des fichiers de configuration que nous allons modifier pour configurer l'utilisation d'une base de données MySQL par CAS:

/bin/cp src/main/webapp/WEB-INF/cas.properties src/main/webapp/WEB-INF/cas.properties.back
/bin/cp src/main/webapp/WEB-INF/deployerConfigContext.xml src/main/webapp/WEB-INF/deployerConfigContext.xml.back

Nous pouvons maintenant modifier les fichiers d'origine pour intégrer les modifications nécessaires à l'utilisation d'une base de données MySQL.

En premier lieu, nous modifions le type de base de données utilisée pour la fonction hibernate:

/bin/sed -i -e 's/^database\.hibernate\.dialect.*/#\0/' \
            -e 's/^[#]*\(database\.hibernate\.dialect.*MySQLDialect.*\)/\1/' \
         src/main/webapp/WEB-INF/cas.properties

Une fois ceci fait, nous allons modifier le fichier deployerConfigContext.xml qui contient une description XML des différents objets à instancier pour vérifier les utilisateurs à l'aide d'une base de données MySQL.

Nous ajoutons l'espace de nommage tx:

/bin/sed -i -e 's|<beans |\0xmlns:tx="http://www.springframework.org/schema/tx" |' \
            -e 's|xsi:schemaLocation="|\0http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd |' \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Nous commentons les éléments de configuration que nous allons remplacer par leurs alternatives MySQL:

• Le gestionnaire d'identification de test:
  

  /bin/sed -i -e '/<bean$/N;s|<\(bean.*SimpleTestUsernamePasswordAuthenticationHandler.*/\)>|<!--\1-->|' \
           src/main/webapp/WEB-INF/deployerConfigContext.xml
  

• Le registre de service de test:
  

  /bin/sed -i -e :start -e '/<bean/N;/serviceRegistryDao/N;s|<\(bean.*InMemoryServiceRegistryDaoImpl.*/\)>|<!--\1-->|' \
           src/main/webapp/WEB-INF/deployerConfigContext.xml

Nous ajoutons les éléments de configuration spécifiques à MySQL.

En premier lieu, nous ajoutons la "dataSource", c'est à dire l'élément destiné à contenir les paramètres de connexion à MySQL:

/bin/sed -i -e '/<\/beans>/i\
\
<!-- MySQL database connection -->\
<bean id="dataSource"\
    class="org.springframework.jdbc.datasource.DriverManagerDataSource"\
    p:driverClassName="com.mysql.jdbc.Driver"\
    p:url="jdbc:mysql://MYSQL_HOST:3306/MYSQL_DB"\
    p:username="MYSQL_USERNAME"\
    p:password="MYSQL_USERPWD" />' \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Nous ajoutons le gestionnaire d'entités qui permettra de sauvegarder les transactions et les services dans la base de données:

/bin/sed -i -e '/<\/beans>/i\
\
<!--  Entity manager -->\
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">\
  <property name="dataSource" ref="dataSource"/>\
  <property name="jpaVendorAdapter">\
    <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">\
      <property name="generateDdl" value="true"/>\
      <property name="showSql" value="true" />\
    </bean>\
  </property>\
  <property name="jpaProperties">\
    <props>\
      <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>\
      <prop key="hibernate.hbm2ddl.auto">update</prop>\
    </props>\
  </property>\
</bean>' \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Nous ajoutons le gestionnaire de transactions:

/bin/sed -i -e '/<\/beans>/i\
\
<!--  Transaction manager -->\
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">\
  <property name="entityManagerFactory" ref="entityManagerFactory"/>\
</bean>\
\
<!-- Transaction manager is annotation driven -->\
<tx:annotation-driven transaction-manager="transactionManager"/>' \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Nous ajoutons le registre des services:

/bin/sed -i -e '/<\/beans>/i\
\
<!--  Service registry -->\
<bean id="serviceRegistryDao" class="org.jasig.cas.services.JpaServiceRegistryDaoImpl"\
  p:entityManagerFactory-ref="entityManagerFactory" />' \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Nous ajoutons l'utilitaire de cryptage des mots de passe:

/bin/sed -i -e '/<\/beans>/i\
\
<!--  Password encryption -->\
<bean id="passwordEncoder"\
      class="org.jasig.cas.authentication.handler.PlainTextPasswordEncoder" />' \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Enfin, nous ajoutons le procédé d'identification des utilisateur depuis la base de données MySQL:

/bin/sed -i -e '/class=.*SimpleTestUsernamePasswordAuthenticationHandler/a\
\
<!-- MySQL user authentication -->\
<bean class="org.jasig.cas.adaptors.jdbc.SearchModeSearchDatabaseAuthenticationHandler" >\
  <property name="dataSource" ref="dataSource"/>\
  <property name="passwordEncoder" ref="passwordEncoder"/>\
  <property name="fieldUser" value="USER_LOGIN"/>\
  <property name="fieldPassword" value="USER_PASSWORD"/>\
  <property name="tableUsers" value="USER_TABLE"/>\
</bean>' \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Nous configureons maintenant les dépendances de construction du WAR pour intégrer les dépendances nécessaires à cette nouvelle configuration.

/bin/sed -i -e '/<\/dependencies>/i\
<dependency>\
     <groupId>${project.groupId}</groupId>\
     <artifactId>cas-server-support-jdbc</artifactId>\
     <version>${project.version}</version>\
</dependency>\
<dependency>\
  <groupId>mysql</groupId>\
  <artifactId>mysql-connector-java</artifactId>\
  <version>3.1.11</version>\
  <scope>provided</scope>\
</dependency>\
<dependency>\
  <groupId>org.hibernate</groupId>\
  <artifactId>hibernate-entitymanager</artifactId>\
  <version>3.3.1.ga</version>\
</dependency>\
<dependency>\
  <groupId>org.hibernate</groupId>\
  <artifactId>hibernate</artifactId>\
  <version>3.2.5.ga</version>\
</dependency>\
<dependency>\
  <groupId>concurrent</groupId>\
  <artifactId>concurrent</artifactId>\
  <version>1.3.4</version>\
</dependency>' \
         pom.xml

Et nous retirons les exclusions qui pourrait nous poser un problème:

/bin/sed -i -e '/<exclusion>/N;/groupId/N;/artifactId/N;s|<\(exclusion>.*spring-dao.*</exclusion\)>|<!--\1-->|' \
         pom.xml

Configuration de l'accès à la base de données

Notre fichier de configuration est maintenant prêt à être modifié en accord avec notre base de données. En premier lieu, renseignez les paramètres de connexion à la base de données contenant vos informations d'identification. Pour notre base de données exemple, cela resemble à:

MYSQL_HOST=localhost
MYSQL_DB=CAS
MYSQL_USERNAME=cas
MYSQL_USERPWD=password

Une fois ceci fait, renseignez le nom de la table ainsi que les champs contenant les informations d'identification. Pour notre exemple, cela ressemble à:

USER_LOGIN=login
USER_PASSWORD=password
USER_TABLE=user

Appliquez maintenant ces paramètres à votre fichier de configuration à l'aide de la commande suivante:

/bin/sed -i -e "s/MYSQL_HOST/${MYSQL_HOST}/" \
            -e "s/MYSQL_DB/${MYSQL_DB}/" \
            -e "s/MYSQL_USERNAME/${MYSQL_USERNAME}/" \
            -e "s/MYSQL_USERPWD/${MYSQL_USERPWD}/" \
            -e "s/USER_LOGIN/${USER_LOGIN}/" \
            -e "s/USER_PASSWORD/${USER_PASSWORD}/" \
            -e "s/USER_TABLE/${USER_TABLE}/" \
         src/main/webapp/WEB-INF/deployerConfigContext.xml

Il ne reste plus qu'a créer le WAR.

Remarque: Si vous souhaitez vous plonger plus en avant dans la configuration de CAS, une très bonne documentation est disponible à l'adresse suivante:

http://www.ja-sig.org/wiki/display/CASUM/Configuring

Création du WAR adéquat

Nous nous plaçons dans le dossier des sources:

cd /usr/src/cas-server-${VERSION}/cas-server-webapp

Et nous recréons le fichier WAR:

/usr/local/bin/mvn package install

Une fois ceci fait, placez le WAR du serveur CAS dans le dossier des applications de Tomcat:

/bin/cp /usr/src/cas-server-${VERSION}/cas-server-webapp/target/cas.war /var/lib/tomcat5/webapps/cas.war

Et redémarrez le serveur Tomcat 5:

/etc/init.d/tomcat5 restart

Vous pouvez maintenant accéder à votre installation du serveur CAS à l'adresse:

http://localhost:8180/cas/login

Pour tester votre installation, saisissez l'identifiant suivant (que nous avons inséré plus haut dans la base de données):

• Identifiant: admin
• Mot de passe: test
  

CAS PHP

Installez Pear et php-curl:

/usr/bin/apt-get install php-pear php5-curl

Mettez à jour Pear:

/usr/bin/pear channel-update pear.php.net
/usr/bin/pear upgrade PEAR

Installez CAS PHP:

/usr/bin/pear install http://www.ja-sig.org/downloads/cas-clients/php/1.0.1/CAS-1.0.1.tgz

Remerciements

• Merci aux développeurs de Central Authentication Service.
• Merci aux rédacteurs du Manuel utilisateur CAS.
• Merci aux développeurs du connecteur JDBC MySQL.