Category Archives: Français

Activer le Log OpenLDAP

160 Replies

Objectif: Cette 3eme partie de la série OpenLDAP tutorial a pour objectif d’activer le log OpenLDAP. Pour atteindre cet objectif il faut paramétrer l’installation du serveur d’annuaire OpenLDAP. Cette production est très importante, voire indispensable pour la surveillance et l’utilisation correcte de ce serveur. Pré-requis: OpenlDAP est installé et pré-configuré sur une machine Debian, Ubuntu ou compatibles. cf. la partie 1 et la partie 2 de cette série OpenLDAP Tutorial.

1. Activer les fichiers journaux (Log) du serveur OpenLDAP

sudo ldapsearch -Y external -H ldapi:/// -b cn=config "(objectClass=olcGlobal)" olcLogLevel -LLL > slapdlog.ldif
Cette commande crée le fichier slapdlog.ldif dont le contenu est le résultat de la requête LDAP exécutée par l’utilitaire ldapsearch: 
dn: cn=config
olcLogLevel: none
La première ligne contient le DN (distinguished name) qui est l’identifiant unique de l’entrée. La deuxième ligne contient l’unique attribut demandée par la requête avec comme valeur: none. La génération de log est désactivée par défaut. Modifier ce fichier pour que son contenu devienne: 
dn: cn=config
changeType: modify
replace: olcLogLevel
olcLogLevel: stats
Maintenant ce fihier LDIF (Lightweight data interchange format) contient une commande de modification: la deuxième ligne déclare qu’on veut modifier l’entrée, la troisième indique qu’il s’agit d’un remplacement de contenu de l’attribut olcLogLevel de cette entrée et la troisième indique la nouvelle valeur de cet attribut. stats permet de générer les logs des connexions, des opérations et de leurs résultats ce qui est parfait pour une surveillance quotidienne. Pour exécuter la commande de ce fichier sur le serveur, on utilise: 
sudo ldapmodify -Y external -H ldapi:/// -f slapdlog.ldif
Si on obtient le message: modifying entry “cn=config”, l’opération a réussi. Pour vérifier: 
sudo ldapsearch -Y external -H ldapi:/// -b cn=config "(objectClass=olcGlobal)" olcLogLevel
Normalement la prise en compte par le serveur est immédiate et aucun redémarrage n’est nécessaire. Le serveur envoi les logs produits au mécanisme de gestion des logs système. Il s’agit de rsyslog pour les versions récentes.

2. Prise en compte des log OpenLDAP par rsyslog

Créer un fichier de configuration dans dans le dossier /etc/rsyslog.d/, choisir un nom quelconque: 10-slapd.conf par exemple. Le chiffre dans le nom permet de classer les fichiers dans ce dossier. Ce fichier contient l’unique ligne: 
local4.*    /var/log/slapd.log;slapdtmpl
slapdtmpl est un nom au choix qui désigne un format de présentation du contenu de ce fichier de log. Il s’agit donc de créer ce format, cela se fait dans le fichier de configuration de rsyslog: 
sudo vi /etc/rsyslog.conf
Dans l’éditeur ajouter ce qui suit, en dessous de la première ligne à partir du début qui commence par $template: 
$template slapdtmpl,"[%$DAY%-%$MONTH%-%$YEAR% %timegenerated:12:19:date-rfc3339%] %app-name% %syslogseverity-text% %msg%\n"
Pour plus de détails sur la créations de format pour rsyslog consulter le manuel: 
man rsyslog.conf
Voir, notamment, le paragraphe TEMPLATES. Enfin il faut redémarrer rsyslog pour que le nouveau paramétrage soit pris en compte: 
service rsyslog restart

3. Tester cette fonctionnalité du serveur OpenLDAP

Lancer une requête et consulter le contenu du fichier /var/log/slapd.log: 
sudo ldapsearch -Y external -H ldapi:/// -b dc=ldaptuto,dc=net
sudo cat /var/log/slapd.log
Normalement, on doit avoir un contenu assez significatif de ce qui a été exécuté par le serveur OpenLDAP.]]>

OpenLDAP tutorial (2) – Modifier les paramètres par défaut

Objectif: Ce 2eme article de la série  «OpenLDAP tutorial» vise à améliorer la configuration basique du serveur vue dans le 1er article. Il s’agit d’une reconfiguration qui permet de personnaliser les paramètres pris par défaut par la procédure d’installation. Cette reconfuguration permet de préparer le servuer à une utilisation dans un environnement réel. Pré-requis: Le serveur OpenLDAP est installé avec sa configuration par défaut. L’installation est supposée faite sur une machine Debian / Ubuntu ou compatibles. L’installation initiale par l’utilitaire apt-get utilise les paramètres systèmes pour effectuer certaines configurations, notamment le DIT de l’annuaire. Ceci peut être reconfiguré. Toutefois cette reconfiguration doit être faite avant toute alimentation du serveur d’annuaire avec des données. La raison est que cette opération réinitialise la base de données et remet son contenu à zéro. Cette reconfiguration se fait avec la commande: 

sudo dpkg-reconfigure slapd
Suite à cela une série d’écrans s’affichent l’un après l’autre pour demander de saisir des paramètres ou effectuer des choix.

Reconfiguration d’OpenLDAP – étape 1Reconfiguration d’OpenLDAP – étape 2

Par défaut c’est le nom de domaine configuré pour la machine hôte qui est pris. Saisir le nom de domaine, ceci fixe le DIT de l’annuaire. Ici : dc=ldaptuto,dc=net (pour la saisie de ldaptuto.net).

Reconfiguration d’OpenLDAP – étape 3

Saisir le nom de l’organisation, un libellé rattaché au DIT de l’annuaire. Ne sert que pour l’information.

Reconfiguration d’OpenLDAP – étape 4

Mot de passe de l’administrateur de l’annuaire qui est cn=admin,dc=ldaptuto,dc=net. L’adminstrateur possède tous les droits et n’est soumis à aucune restriction configurée (équivalent de root pour les systèmes unix).

Reconfiguration d’OpenLDAP – étape 5

Le type de base de données à utiliser. OpenLDAP peut fonctionne avec plusieurs types de bases de données dont BDB, HDB et MDB qui sont proposées par la procédure d’installation. MDB est la base de données recommandée. Elle est plus compacte et performante que HDB et BDB. MDB fonctionne sans configuration particulière et permet de renommer un sous ensemble de l’annuaire (un  noeud quelconque) tout comme HDB.

Reconfiguration d’OpenLDAP – étape 6

Comportement à la désinstallation puis la purge du paquet slapd. Choisir si les fichiers des données doivent être supprimés ou non (<Non> est plus prudent, <Oui> est plus efficace).

Reconfiguration d’OpenLDAP – étape 7

Répondre par <Oui>. les fichiers de données seront déplacés de /var/lib/ldap vers /var/backup

Reconfiguration d’OpenLDAP – étape 8

Répondre <Non>, sauf il y a une bonne raison (généralement maintenir une compatibilité avec un système ancien) pour le faire. A la suite de cette étape, le serveur d’annuaire est réinitialisé et redémarré.

Vérifier le nouveau paramétrage

sudo ldapsearch -Y external -H ldapi:///  -b dc=ldaptuto,dc=net ↵

SASL/EXTERNAL authentication started
SASL username: gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth
SASL SSF: 0
# extended LDIF
#
# LDAPv3
# base <dc=ldaptuto,dc=net> with scope subtree
# filter: (objectclass=*)
# requesting: ALL
#

# ldaptuto.net
dn: dc=ldaptuto,dc=net
objectClass: top
objectClass: dcObject
objectClass: organization
o: OpenLDAP tutorial
dc: ldaptuto

# admin, ldaptuto.net
dn: cn=admin,dc=ldaptuto,dc=net
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator

# search result
search: 2
result: 0 Success

# numResponses: 3
# numEntries: 2
On remarquera dc=ldaptuto,dc=net et le libellé du DIT o: OpenLDAP tutorial]]>

Openldap tutorial – Installation et configuration de base

« OpenLDAP tutorial », basée sur la pratique. La démarche de l’exposé se fait pas à pas en montrant tous les détails nécessaires au bon fonctionnement final. L’installation exposée comprend une configuration minimale pour un fonctionnement correcte. D’autres articles suivront pour améliorer l’installation sur différents aspects. Il est conseillé de suivre cette serie d’articles dans l’ordre.

  1. Cet article: Installation et configuration de base
  2. Modifier les paramètres par défaut
  3. Activer le Log OpenLDAP
  4. Accès à la configuration dynamique par l’administrateur
  5. Organisation et types de données
  6. Ajouter des données à l’annuaire
  7. Utilisation pour protéger l’accès à un site web
  8. OpenLDAP password policy – gérer les comptes des utilisateurs
Pré-requis: Aucun à propos du serveur OpenLDAP. There is an english version of this series of articles.

Openldap tutorial, étape 1: Configurer correctement l’hôte Debian / Ubuntu.

La procédure d’installation du serveur met en place systématiquement une base de données. Le DIT (équivalent de l’instance pour les bases de données relationnelles) est sélectionné en fonction du nom de domaine de la machine hôte. 
hostname -f
Cette commande retourne le nom complet (full) de la machine. Exemple: desktop.meddeb.net. Dans ce cas la base de données aura pour DIT: dc=meddeb,dc=net (la partie droite du nom à partir du 1er point rencontré). Si la configuration ne vous convient pas, il faudrait la modifier (fichier /etc/hostname et /etc/hosts)

Openldap tutorial, étape 2: installer le serveur Openldap sur Debian / Ubuntu.

sudo apt-get purge slapd
sudo apt-get install slapd
La procédure d’installation se lance et demande le mot de passe de l’administrateur du serveur. openldap tutorial, openldap ubuntu, openldap debianEn plus des fichiers binaires exécutables, il est installé dans les dossiers:
  • /usr/lib/ldap/ : librairies des modules (overlay), fichiers binaires natifs
  • /etc/ldap/schema/ : Schémas disponibles par défaut, fichiers texte.
  • /etc/ldap/slap.d/ : Configuration dynamique, fichiers texte.
  • /var/lib/ldap/ : Données, fichiers de la base de données installée.
  • /var/run/slapd/ : Paramètres d’exécution, fichiers texte.

Openldap tutorial, étape 3: installer les utilitaires client de Openldap.

sudo apt-get install ldap-utils
Ceci installe les utilitaires clients Openldap, notamment l’utilitaire d’interrogation ldapsearch. Le fichier de configuration de ces utilitaires /etc/ldap/ldap.conf peut être très utile dans le mesure où il permet de fixer des paramètres par défaut. Cela simplifie l’interaction avec le serveur. Un contenu typique de ce fichier est: 
BASE   dc=meddeb,dc=net
URI    ldap://localhost
SIZELIMIT      12
TIMELIMIT      15
DEREF          never
# TLS certificates (needed for GnuTLS)
TLS_CACERT      /etc/ssl/certs/ca-certificates.crt

Openldap tutorial, étape 4: Vérifier l’installation.

slapd -V ↵

@(#) $OpenLDAP: slapd  (Ubuntu) (May 11 2016 16:12:05) $
        buildd@lgw01-10:/build/openldap-mF7Kfq/openldap-2.4.42+dfsg/debian/build/servers/slap
La version du serveur installée est 2.4.42 
ldapsearch -Y external  -H ldapi:/// -b cn=config "(objectClass=olcGlobal)" -LLL ↵
SASL/EXTERNAL authentication started
SASL username: gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth
SASL SSF: 0
dn: cn=config
objectClass: olcGlobal
cn: config
olcArgsFile: /var/run/slapd/slapd.args
olcLogLevel: none
olcPidFile: /var/run/slapd/slapd.pid
olcToolThreads: 1
Ceci donne la partie globale de la configuration mise en place par défaut. On retrouve l’indication des deux fichiers des paramètres d’exécution dans le dossier /var/run/slapd/. On remarquera le paramètre olcLogLevel à none, à modifier impérativement. 
sudo ldapsearch -Y external  -H ldapi:/// -b dc=meddeb,dc=net -LLL ↵

ASL/EXTERNAL authentication started
SASL username: gidNumber=0+uidNumber=0,cn=peercred,cn=external,cn=auth
SASL SSF: 0
dn: dc=meddeb,dc=net
objectClass: top
objectClass: dcObject
objectClass: organization
o: meddeb.net
dc: meddeb

dn: cn=admin,dc=meddeb,dc=net
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator
Ceci donne les deux seules entrées créées dans l’annuaire par défaut:
  • dc=meddeb,dc=net, qui représente le DIT de l’annuaire.
  • cn=admin,dc=meddeb,dc=net, qui est l’administrateur de l’annuaire dont le mot de passe a été saisie au cours de l’installation.
]]>

Tutoriel Maven – Tests unitaires Java

Objectif: Ce tutoriel Maven concerne la mise en place de test unitaire java avec cet outil. Par défaut, à la génération d’un nouveau projet, Maven met en place tout ce qu’il faut pour intégrer un test unitaire java. Il s’agit de la branche test de l’arborescence créée, cf. l’article Tutoriel Maven 3 – partie 2. Dans ce tutoriel Maven on verra comment mettre en place ce test unitaire java, comment le contourner en cas de besoin et l’intérêt de cette fonctionnalité dans le processus de développement de logiciels. Pré-requis: le JDK est installé, cf. l’article: Installer Java sur Ubuntu ou compatible et Maven 3 est installé cf. l’artice: Tutoriel Maven 3 – partie 1

1. Maven test unitaire Java est mis en place par défaut à la génération du projet

mvn archetype:generate -DgroupId=com.example.calculateur \
    -DartifactId=calculteur -Dversion=1.0 -Dpackage=com.example.calculateur \
    -DinteractiveMode=false
ls calculateur/src/test/java/com/exemple/calculateur/
AppTest.java
La classe AppTest.java a été générée pour contenir le code des tests. La dépendance au framework JUnit a été rajoutée dans le fichier pom.xml 
.....
<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
    <scope>test</scope>
  </dependency>
</dependencies>
.....

2. Simuler une erreur de test unitaire Java

Dans le code de la classe AppTest.java, repérer: 
public void testApp()
{
   assertTrue( true );
}
Et modifier en: 
public void testApp()
{
   assertTrue( false );
}
Après cela si on lance la reconstruction de l’application, l’opération échoue à cause de test non concluant. 
mvn clean package
..
..
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.exemple.calculateur.AppTest
Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.46 sec <<< FAILURE!

Results :

Failed tests:   testApp(com.exemple.calculateur.AppTest)

Tests run: 1, Failures: 1, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE

3. Ajouter les fonctions de calcul à l’application

Ajouter une classe qui se charge des calculs: Calc.java et activer l’appel au calcul dans App.java 
package com.exemple.calculateur;
public class Calc
{
  private int getInt(String s) {
    int resultat = -1;
    try {
      resultat = Integer.parseInt(s);
    }
    catch (NumberFormatException e) {
      resultat = -1;
    }
    finally {
      return resultat;
    }
  }
  public int somme(String s1, String s2)
  {
    int i1 = getInt(s1);
    int i2 = getInt(s2);
    int resultat = i1 + i2;
    return resultat;
  }
  public int multiplication(String m1, String m2)
  {
    int i1 = getInt(m1);
    int i2 = getInt(m2);
    int resultat = i1 * i2;
    return resultat;
  }
}
// Dans App.java
public static void main( String[] args )
{
  if (args.length != 3) {
    System.out.println("Opération non supportée.");
    System.exit(1);
  }
  String operation = args[1];
  Calc calc = new Calc();
  int resultat = -1;
  if (operation.equalsIgnoreCase("+")) {
    resultat = calc.somme(args[0], args[2]);
  } else if (operation.equalsIgnoreCase("x")) {
    resultat = calc.multiplication(args[0], args[2]);
  }
  if (resulat >= 0) {
    System.out.println("Résultat: " + resultat);
  } else System.out.println("Opération non supportée");
}
Ce code a été écrit pour répondre au cahier des charges suivant:
  1. Le calculateur peut effectuer les opérations d’addition et de multiplication.
  2. Les opérations ne portent que sur des nombres entiers positifs ou nul.
  3. On passe trois arguments au calculateur, dans l’ordre: 1er opérande, opération, 2eme opérande.
  4. En cas d’erreur d’utilisation le calculateur répond par le message “Opération non supportée”.

4. Ajouter le test unitaire Java en conformité avec le cahier des charges

Ce test doit contrôler le fonctionnement des méthodes de la classe Calc qui effectue le calcul et constitue le cœur de cette application. Commençons par la méthode Calc.somme(String s1, String s2). Dans AppTest.java on va modifier le code, cette fois pour inclure les tests. 
public void testApp()
{
  Calc calc = new Calc();
  assertEquals(calc.somme("321", "425"), 746);
  assertTrue(calc.somme("abc", "cba") < 0);
  assertTrue(calc.somme("abc", "653") < 0);
  assertTrue(calc.somme("-145", "153") < 0);
}
A la construction de l’application le troisième test échoue. En révisant le code de la classe Calc, on s’aperçoit de l’erreur et on corrige le code de la méthode Calc.somme(String s1, String s2) 
public int somme(String s1, String s2)
{
  int resultat = -1;
  int i1 = getInt(s1);
  int i2 = getInt(s2);
  if ((i1 >= 0) && (i2 >= 0)) resultat = i1 + i2;
  return resultat;
}
Après cette correction, la construction de l’application se fait sans échec. Vous pouvez vous exercer en mettant en place les tests pour la deuxième méthode de multiplication.

5. Désactiver le test unitaire Java

Dans certains cas, on pourrais avoir besoin de désactiver la phase de test afin de forcer la construction de l’application. Cela peut se faire de deux façons.

5.1. En ligne de commande

mvn -Dmaven.test.skip=true package

5.2. En modifiant le fichier pom.xml

Dans le fichier pom.xml du projet, ajouter la référence au plug-in surefire. Remarquer le paramètre: <skipTests>true</skipTests> 
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <version>2.18.1</version>
  <configuration>
    <skipTests>true</skipTests>
  </configuration>
</plugin>
]]>

Tutoriel Maven 3 – partie 2

Objectif de la partie 2 du tutoriel Maven: Cette 2eme partie du tutoriel Maven vise à construire pas à pas une application java qui s’exécute simplement en ligne de commande en invoquant le nom du fichier. L’application ne fait qu’afficher un message sur la console (sortie standard) mais peut servir de point de départ afin de construire ce type d’application. Prére-requis: le JDK est installé, cf. l’article: Installer Java sur Ubuntu ou compatible et Maven 3 est installé cf. l’artice: Tutoriel Maven 3 – partie 1

1. Première partie de ce tutoriel Maven: génerer un squelette d’application en ligne de commande

La commande à utiliser est: 
mvn archetype:generate -DgroupId=com.example.hello \
    -DartifactId=helloworld -Dversion=1.0 -Dpackage=com.example.helloworld \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DinteractiveMode=false
Remplacer: com.exemple.hello, helloworld, 1.0, com.example.helloworld  par les valeurs personnalisées de votre choix. Ceci crée l’arborescence de code source Java suivante: tutoriel maven structure helloworldIl s’agit de l’arborescence par défaut d’un projet Java Maven. Les codes source sont dans un dossier qui s’appelle src. Deux branches sont sous src:
  • test: contient les sources des test unitaires. Ce sujet ne sera pas abordé pour le moment.
  • main: contient les sources de l’application (dans le sous dossier java)
On remarque aussi la génération d’une classe Java unique qui constitue le point d’entrée de l’application App.java.

1.1. Construire l’application

Depuis le dossier helloworld/ de l’application: 
mvn package
Ceci génère le fichier jar de l’application: helloworld-1.0.jar dans le sous-dossier target/

1.2. Exécuter cette application modèle

Depuis le dossier helloworld/ de l’application: 
java -cp target/helloworld-1.0.jar com.example.helloworld.App
Hello World !
On est encore loin du but car il a fallu invoquer java avec deux paarmètres: le classpath et la classe principale.

2. Deuxième partie de ce tutoriel Maven: créer un jar exécutable

Pour cela on va utiliser le plug-in maven-assembly-plugin. On modifie donc le fichier pom.xml généré pour y ajouter toute la partie entre les balises <build> 
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example.hello</groupId>
  <artifactId>helloworld</artifactId>
  <packaging>jar</packaging>
  <version>1.0</version>
  <name>helloworld</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
              <mainClass>com.example.helloworld.App</mainClass>
            </manifest>
          </archive>
          <descriptorRefs>
             <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <appendAssemblyId>false</appendAssemblyId>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
Ensuite, après la reconstruction du fichier jar, l’exécution devient plus simple. On n’a plus à indiquer le nom de la classe principale. Le jar est exécutable de lui même. 
mvn clean package
java -jar target/helloworld-1.0.jar
Hello World!
Il reste, toutefois, encore une étape pour atteindre l’objectif de n’invoquer que le nom du fichier.

3. Troisième partie de ce tutoriel Maven: créer un fichier exécutable.

3.1. Créer un script shell de démarrage

Dans un éditeur de texte, insérer le script suivant puis enregistrer sous le nom de boot.sh dans le dossier helloworld/ 
#!/bin/sh
EXEC=`which "$0" 2>/dev/null`
[ $? -gt 0 -a -f "$0" ] && EXEC="./$0"
java=java
if test -n "$JAVA_HOME"; then
  java="$JAVA_HOME/bin/java"
fi
exec "$java" $java_args -jar $EXEC "$@"
exit 1

3.2. Créer un fichier exécutable manuellement

Maintenant si on exécute la commande: 
cat boot.sh target/helloworld-1.0.jar > hello && chmod +x hello
On obtient un fichier exécutable autonome hello, qui peut être exécuté tout simplement par: 
./hello
Hello World!

3.3. Créer le fichier exécutable par Maven

Pour inclure cette dernière tâche au cycle de vie Maven de notre projet, on utilise le plug-in exec-maven-plugin. Pour cela on rajoute cette portion de code au fichier pom.xml. Insérer juste après le dernier plug-in ajouté. 
<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.3.2</version>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>exec</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <executable>buildexec.sh</executable>
  </configuration>
</plugin>
Remarquez le buildexec.sh inclu dans la balise <executable>. Il s’agit du script que Maven va exécuter pour générer le fichier final et qu’on doit créer. Ce fichier doit effectuer les mêmes tâches que la commande manuelle effectuée précédemment. Il doit inclure donc 
#!/bin/sh
cat boot.sh target/helloworld-1.0.jar > hello
chmod +x hello
A l’aide d’un éditeur de texte, créer ce fichier et le rendre exécutable: 
chmod +x buildexec.sh
Enfin Maven pourra créer le fichier hello exécutable java autonome. 
mvn package
./hello
Hello World!
]]>

Installer JDK d'Oracle sur Linux Debian ou compatibles

Objectif: installer le kit de développement Java (JDK) d’Oracle sur un système GNU/Linux Debian ou compatibles, notamment Ubuntu/Kubuntu pour les machines de bureau. 1. Vérifier la configuration d’apt 

apt-cache search oracle-java
Si le retour de cette commande est vide, il faudra ajouter un dépôt (repository) PPA à la configuration d’apt. Sinon passer directement à 3. 2. Configurer apt 
sudo add-apt-repository ppa:webupd8team/java
ensuite 
apt-get update
3. Lister les versions de JDK Oracle disponibles pour le système 
apt-cache search oracle-java | grep oracle-java[1-9]-installer

oracle-java7-installer - Oracle Java(TM) Development Kit (JDK) 7
oracle-java6-installer - Oracle Java(TM) Development Kit (JDK) 6
oracle-java8-installer - Oracle Java(TM) Development Kit (JDK) 8
4. Installer Oracle JDK version 8 (à titre d’exemple) 
sudo apt-get install oracle-java8-installer
]]>

Installer Java sur Ubuntu ou compatibles

Objectif: installer Java / Ubuntu (JDK ou JRE  -le kit de développement Java  et/ou l’environnement d’exécution Java), sur un système Linux Ubuntu, Debian ou compatibles. Notamment Kubuntu pour les machines de bureau. Rappel: JRE est nécessaire pour exécuter des applications Java, JDK est nécessaire pour construire des applications Java. Parce qu’il n’est pas possible de construire des applications sans pouvoir les exécuter, l’installation de JDK contient toujours JRE. Remarque: Cet article ne traite que l’installation de OpenJDK l’implémentation libre de Java. Le JDK d’Oracle sera traité dans un prochain article.

1. Vérifier les installations de JRE Java / Ubuntu

sudo update-alternatives --list java

/usr/lib/jvm/java-6-openjdk-i386/jre/bin/java
On obtient la liste des JRE avec leurs versions installés (ici version 6 seule). Si on obtient un message d’erreur “pas d’alternatives pour java“, c’est qu’aucune version de JRE n’est installée.

2. Vérifier les installations de JDK Java / Ubuntu

sudo update-alternatives --list javac
On obtient la liste des JDK avec leurs versions installés. Si on obtient un message d’erreur “pas d’alternatives pour javac”, c’est qu’aucune version de JDK n’est installée.

3. Lister les versions de JRE disponibles pour le système

apt-cache search openjdk | grep openjdk-[1-9]-jre | grep -v lib

openjdk-7-jre - environnement d'exécution Java OpenJDK qui utilise Hotspot JIT
openjdk-7-jre-headless - environnement d'exécution Java OpenJDK utilisant Hotspot JIT
openjdk-6-jre-zero - Alternative JVM for OpenJDK, using Zero/Shark
openjdk-7-jre-zero - Alternative JVM for OpenJDK, using Zero/Shark
openjdk-6-jre - environnement d'exécution Java OpenJDK qui utilise Hotspot JIT
openjdk-6-jre-headless - environnement d'exécution Java OpenJDK utilisant Hotspot JIT

4. Installer JRE sur le système Linux Ubuntu (version 7 à titre d’exemple)

sudo apt-get install openjdk-7-jre
Utiliser “openjdk-7-jre-headless” si vous n’avez pas besoin d’interface graphique (cas de machine serveur).

5. Lister les versions de JDK disponibles pour le système

apt-cache search openjdk | grep openjdk-[1-9]-jdk

openjdk-7-jdk - kit de développement OpenJDK - JDK
openjdk-6-jdk - kit de développement OpenJDK - JDK

6. Installer JDK sur le système Linux Ubuntu (version 7 à titre d’exemple)

sudo apt-get install openjdk-7-jdk

7. Configurer le JRE actif sur le système Debian dans le cas d’installation simultanée de plusieurs versions

sudo update-alternatives --config java

  Sélection   Chemin                                         Priorité  État
  ------------------------------------------------------------
  * 0            /usr/lib/jvm/java-7-openjdk-i386/jre/bin/java   1071      mode automatique
    1            /usr/lib/jvm/java-6-openjdk-i386/jre/bin/java   1061      mode manuel
    2            /usr/lib/jvm/java-7-openjdk-i386/jre/bin/java   1071      mode manuel

  Appuyez sur <Entrée> pour conserver la valeur par défaut[*] ou choisissez le numéro sélectionné :
Taper 1 puis “Entrée” pour changer vers la version 6.

8. Configurer le JDK actif sur le système Debian dans le cas d’installation simultanée de plusieurs versions

sudo update-alternatives --config javac

  Sélection   Chemin                                         Priorité  État
  ------------------------------------------------------------
  * 0            /usr/lib/jvm/java-7-openjdk-i386/bin/javac   1071      mode automatique
    1            /usr/lib/jvm/java-6-openjdk-i386/bin/javac   1061      mode manuel
    2            /usr/lib/jvm/java-7-openjdk-i386/bin/javac   1071      mode manuel

  Appuyez sur <Entrée> pour conserver la valeur par défaut[*] ou choisissez le numéro sélectionné :
Taper 1 puis “Entrée” pour changer vers la version 6.]]>

Tutoriel Maven 3 – partie 1

Objectif de la partie 1 du tutoriel Maven:  Installer Maven 3 afin de l’utiliser dans un environnement de développement. Cible: Système Linux Ubuntu ou compatible, notamment Debian pour les machines serveurs (Maven-Debian constitue un couple parfait pour monter un serveur de build et test unitaires pour le développement).

1. Installer Maven 3

sudo apt-get install maven
Remarquer qu’il ne faut pas indiquer la version 3 de Maven dans cette commande.

2. Vérifier l’installation

mvn -version
L’installation et la configuration de Maven a été correctement effectuée si la réponse débute par la ligne (remarquer le numéro de version 3.x.x): 
Apache Maven 3.x.x
A défaut de ce résultat, notamment si on obtient “Apache Maven 2.x.x” il convient d’effectuer une étape supplémentaire de configuration pour activer la version 3 de Maven.

2. Configurer l’installation de Maven

sudo update-alternatives --config mvn
  Selection    Path                       Priority   Status
------------------------------------------------------------
* 0            /usr/share/maven2/bin/mvn   200       auto mode
  1            /usr/share/maven/bin/mvn    150       manual mode
  2            /usr/share/maven2/bin/mvn   200       manual mode

Press enter to keep the current choice[*], or type selection number:
La réponse à la commande: sudo update-alternatives –config mvn , montre l’existence d’une autre version installée en tant que version par défaut. Il convient de modifier la configuration par défaut vers la la ligne qui contient: /usr/share/maven/bin/mvn (dans l’exemple la ligne 1). Taper donc 1 et Entrée. Remarque: La désinstallation de la version 2 de Maven par: 
sudo apt-get remove maven2
Définira automatiquement la version 3 comme version par défaut. Ceci peut constituer une alternative à la configuration.]]>

Utiliser TomEE avec Eclipse

Objectif: Configurer Eclipse pour utiliser le serveur d’applications TomEE comme cible de développement. Prérequis: TomEE est installé sur la machine locale cf. l’article “Installer TomEE” 1. Activer la perspective Java JEE Soit activer le bouton dans le coin supérieur droit. Soit utiliser le menu: Window / Open perspective / Other… puis choisir Java EE dans la liste 2. Faire apparaître l’onglet “Servers” du volet bas Utiliser le menu: Window / Show View / Servers eclipse-tomee-1 3. Paramétrer TomEE Cliquer sur le lien “No servers are available…” eclipse-tomee-2 Une fenêtre de paramétrage d’un nouveau serveur s’affiche. eclipse-tomee-3Choisir: Apache / Tomcat v7.0 server. Ensuite “Next” eclipse-tomee-4eclipse-tomee-5 Saisir un nom significatif et utiliser le bouton “Browse..” pour sélectionner l’emplacement d’installation de TomEE. Utiliser ensuite le bouton “Next” et “Finish” dans le dernier écran. eclipse-tomee-6TomEE est désormais intégré à Eclipse et peut exécuter des applications pendant leur développement.]]>

Postgres pgAdmin 3 pour administrer PostgreSQL

 Objectif: Postgres pgAdmin est un outils d’administration du serveur de base de données PostgreSQL. L’objectif est donc de pouvoir administrer / utiliser PostgreSQL de manière simple (dans le sens création, modification et suppression d’objets du serveur: utilisateurs, bases de données, tables…) avec cet utilitaire à interface graphique.

Cible: GNU Linux Ubuntu ou compatible, équipé d’un gestionnaire de bureau (KDE, GNOME ..)

Cet article fait partie d’une série qui concerne le serveur de bases de données PostgreSQL et son utilisation dans un environnement de développement:
  1. Installation de base de PostgreSQL
  2. Cet article: Utiliser Postgres pgAdmin 3 pour administrer PostgreSQL
  3. Installer PostgreSQL 10
  4. Reconfigurer l’installation par défaut de PostgreSQL 10
  5. Utiliser PostgreSQL 10 dans un environnement de développement
  6. Administrer PostgreSQL avec psql
  7. Postgres pgAdmin 4 : installation et configuration
  8. Postgres pgAdmin 4: Utilisation courante

1. Installer Postgres pgAdmin 3

sudo apt-get install pgadmin3
S’agissant d’une interface graphique, son icône de lancement devrait alors apparaître dans les menus du bureau. Sous KDE par exemple : Menu K / Applications / Développement, pgAdmin III (avec une tête d’éléphant comme icône).

2. Paramétrage de base de Postgres pgAdmin

Le premier lancement de pgAdmin donne l’écran: Postgres pgAdmin écran initial Utiliser le menu: Fichier / Ajouter un serveur… Postgres pgAdmin ajouter serveur Nom: Serveur local, ne sert que pour l’affichage, choix libre. Hôte: localhost si le serveur est installé sur la même machine que pgAdmin. Sinon adresse (IP ou DNS) de la machine distante. Port: 5432 par défaut Base de maintenance: postgres créée et existe par défaut Nom utilisateur:  admin Celui qui a été créée à l’installation du serveur (cf. l’article à ce sujet).      

A la validation l’accès au serveur est disponible

Postgres pgAdmin accés serveur On remarquera la présence de l’unique base de donnée postgres et de l’utilisateur (rôle de connexion) postgres. Ce sont les deux objets créées par défaut lors de l’installation du serveur. On remarquera aussi la présence de l’utilisateur admin qui a été créée après l’installation du serveur (cf. l’article à ce sujet).          

3. Création d’une base de données

  • Se positionner sur le nœud “Base de données (1)“
  • Clic k droit et utiliser le menu contextuel “Ajouter une base de données…“
pgAdmin création BD Nom: Nom significatif, unique sur le même serveur. Propriétaire: Choisir l’utilisateur dans la liste. Commentaire: Facultatif mais très utile pour la documentation.               A la validation, la base de données est créée. Postgres pgAdmin BD créée

4. Création de tout autre objet avec Postgres pgAdmin

Le même mode de fonctionnement est, généralement,  valable pour la création de tout autre objet:
  • Se positionner sur le nœud correspondant au type de l’objet cible: schéma, table..
  • Clic k droit et utiliser le menu contextuel
]]>