Imaginons que vous vous intéressiez à l’Intelligence Artificielle et que vous n’êtes pas peu fier d’avoir entraîné votre tout premier modèle. Prenons l’exemple d’une corrélation entre la vitesse d’affichage des pages d’un site web d’e-commerce et le montant moyen d’un panier (cela a été étudié de long en large : les sites d’e-commerce lents font fuir les acheteurs):

Un modèle de régression linéaire permettrait de prédire le montant moyen des achats pour un temps moyen d’affichage de 7 secondes (dans notre exemple cela tournerait autour de 70€).

import numpy as np
from sklearn.linear_model import LinearRegression

#Acquisition des données
pageSpeeds = np.random.normal(3.0, 1.0, 1000)
purchaseAmount = 100 - (pageSpeeds + np.random.normal(0, 0.1, 1000)) * 3

#Entraînement du modèle
model = LinearRegression()
model.fit(pageSpeeds.reshape(-1, 1), purchaseAmount)

#Prédiction
purchasePredict = model.predict([[7.0]])

print("Prediction={:.4f}".format(purchasePredict[0]))

Décomposons maintenant le code d’un point de vue de la performance applicative. La partie la plus coûteuse concerne l’acquisition des données et l’entraînement du modèle.

Comment réutiliser plusieurs fois cet utilitaire de prédiction (en ligne de commande ou par un service web) ? Les données sur lesquelles nous avons entraîné le modèle variant peu, il serait dommage de répéter à chaque appel de l’utilitaire l’acquisition des données et l’entraînement du modèle. Dans le cas d’une application métier ou d’un site Internet, cela nuirait grandement aux performances. Et à plus forte raison avec des modèles plus lourds (deep learning, modèles itératifs, etc.).

Qu’est que la sérialisation d’un objet ?

Lorsque l’on crée un objet (l’instance d’une classe comme la variable model dans notre code Python), il existe aussi longtemps que le programme dans lequel il a été créé est en vie. Dit autrement, lorsque le programme s’arrête, tous les objets créés en mémoire par ce programme disparaissent.

L’idée de la sérialisation est de rendre persistants (en les enregistrant sur le disque dur) certains objets dont on aurait besoin lorsque le programme démarre de nouveau. Dans le cas d’un service web cela concerne chaque appel au service.

Avec Python, la librairie de référence dépend du cas de figure. Joblib est à privilégier si l’on doit sérialiser de grands tableaux de nombres numpy. Tandis que pickle se montre généralement plus rapide dans les autres cas de figure.

Exemple d’un utilitaire en ligne de commande

Nous travaillerons dans le même répertoire pour tous les exemples de code qui suivent. On commencera par découper notre code en deux parties:

1. Un utilitaire d’acquisition des données et d’entraînement du modèle qu’on lancera de temps en temps afin de rafraîchir le modèle.
2. Un utilitaire en ligne de commande que l’on utilisera après avoir entraîné le modèle une première fois et de manière beaucoup plus fréquente.

Reprenons le code précédent afin de lui ajouter la sauvegarde du modèle dans un fichier du répertoire courant.

import joblib
import numpy as np
from sklearn.linear_model import LinearRegression

#Acquisition des données et entraînement du modèle
pageSpeeds = np.random.normal(3.0, 1.0, 1000)
purchaseAmount = 100 - (pageSpeeds + np.random.normal(0, 0.1, 1000)) * 3
model = LinearRegression()
model.fit(pageSpeeds.reshape(-1, 1), purchaseAmount)

#Sérialisation du modèle pour utilisation future
joblib.dump(model, "./model.joblib")

Puis créons un deuxième utilitaire qui prendra en paramètre (par la ligne de commande) le temps de réponse et prédira le montant moyen d’achat. On l’invoque dans le terminal de cette manière: python predictor.py 7.0

import sys
import joblib

#Récupérer le temps de réponse passé en paramètre
responseTime = float(sys.argv[1])

#Charger le modèle depuis le fichier
model = joblib.load("./model.joblib")

#Prédire le montant moyen d'achat 
purchasePredict = model.predict([[responseTime]])
print("Prediction={:.4f}".format(purchasePredict[0]))

Utilisation dans un service web

Le principe reste le même pour un service web. On conserve l’utilitaire d’entraînement du modèle. Puis on crée avec le framework Flask (qu’il faudra installer au préalable avec pip ou conda) une application web minimaliste.

import joblib
from flask import Flask
from flask import request

app = Flask(__name__)
@app.route('/<perfRespTime>')
def index(perfRespTime):
    #Charger le modèle depuis le fichier
    model = joblib.load("./model.joblib")
    #Prédire le montant d'achat à l'aide du modèle
    purchasePredict = model.predict([[float(perfRespTime)]])
    #Afficher le résultat dans le navigateur
    return("Prediction={:.4f}".format(purchasePredict[0]))

app.run(host='localhost', port=5000)

L’utilisation se passe en deux temps:

1. On lance un serveur web depuis la console: python webservice.py ce script écoute sur le port numéro 5000 des appels via le protocole HTTP.
2. Dans le navigateur on accède à l’URL http://localhost:5000/7.0 (elle contient l’adresse du serveur web et le paramètre 7.0 qui correspond au temps de réponse pour lequel on souhaite prédire le montant moyen d’achat). Notez que des applications telles que curl ou postman peuvent être utilisées à la place du navigateur.

Il ne vous a sans doute pas échappé que le modèle était chargé à chaque appel du service web. En cas d’utilisation fréquente, on pourrait le mettre dans une variable statique ou globale (initialisée une fois pour toutes) ou utiliser les fonctionnalités de cache de joblib. Plusieurs choses seront alors à prendre en compte comme le nombre de services et modèles, ainsi que la quantité de mémoire disponible sur la machine.

Aller plus loin

Bien entendu, dans le cadre d’une application d’entreprise, il faudra inclure notre script dans une solution plus robuste (en incluant dans un serveur web et en y ajoutant par exemple une méthode d’authentification) et réfléchir à la mise à l’échelle. Si vous utilisez une plateforme cloud telle qu’AzureML sachez que les principes techniques et les bibliothèques python sont les même pour déployer un service web basé sur un modèle.

Cet article Comment utiliser un modèle de ML dans une application? est apparu en premier sur Benjamin BALET.

Introduction

Il existe une démo en ligne du logiciel Jorani, mais cette dernière ne permet pas de tester sereinement toutes les fonctionnalités offertes par ce logiciel de gestion des congés. Tout simplement parce que cette démo est publique. Il n’est donc pas possible d’empêcher un autre internaute de supprimer ou de valider ou de supprimer ses données de test. Il n’est pas non plus possible de tester des fonctionnalités telles que l’authentification LDAP.

Prérequis

• Télécharger et installer le logiciel WAMP (ou une alternative).
• Récupérer la dernière version du logiciel Jorani.

Configurer WAMP

Configuration d’Apache

Activer la réécriture d’URL

Jorani utilise la technique de réécriture des URL. Par exemple, l’adresse

http://localhost/lms/ index.php ?route=leaves/104

Sera transformée en :

http://localhost/lms/leaves/104

Ce qui est quand même plus lisible. Mais pour cela, il faut activer le module Apache de réécriture des URLs. Faire apparaître l’icône WAMP dans la barre des tâches et faire un clic droit. Dans le menu Apache, choisir, Apache modules puis vérifier si rewrite_module est actif. Pour l’activer, il suffit de cliquer dessus et WAMP redémarrera.

On peut aussi activer ce module en vérifiant que la ligne ci-dessous ne commence pas par le signe dièse (# transforme la ligne en commentaire) dans le fichier httpd.conf de votre répertoire d’installation d’Apache.

LoadModule rewrite_module modules/mod_rewrite.so

Permettre la surcharge de la configuration

Jorani utilise des fichiers .htaccess afin de modifier quelques éléments de configuration d’Apache (par curiosité, vous pourriez ouvrir le fichier .htaccess qui est à la racine du projet LMS).

Ouvrir le fichier http.conf (soit par le raccourci accessible en faisant un clic droit sur l’icône WAMP de la barre des tâches, soit par l’explorateur en cherchant le répertoire d’installation d’Apache). Chercher le bloc de ligne ci-dessous. Le contenu peut varier, mais ce qui est important, c’est la présence de la directive AllowOverride All :

<Directory />
    Options +FollowSymLinks
    RewriteEngine On
    AllowOverride All
    Order deny,allow
    Deny from all
</Directory>

Configuration de PHP

Il est conseillé d’activer le module open_ssl. Pour vérifier si cette extension PHP est active, faire comme dans le paragraphe précédent sauf que le nom du menu est PHP puis PHP extensions :

Si vous souhaitez tester la connexion à LMS via l’annuaire LDAP de votre entreprise, il faudra également vérifier que le module PHP LDAP (php_ldap) est bien activé.

Installer Jorani

Récupérer une version de Jorani depuis github. Décompresser le fichier ZIP que vous avez téléchargé depuis github dans le répertoire web de WAMP (en général C:\wamp\www\). Voici ce que vous devriez obtenir :

Déplacer les fichiers si la profondeur du répertoire n’est pas la bonne (par exemple C:\wamp\www\lms\lms\application devrait être C:\wamp\www\lms\application).

Installer la base de données

WAMP contient une interface web d’administration des bases de données MySQL que l’on peut lancer directement depuis l’icône de la barre des tâches :

Se connecter à phpMyAdmin, puis cliquer sur l’onglet « Bases de données » afin de créer une nouvelle base avec interclassement utf8_general_ci:

Note : les utilisateurs avancés peuvent créer un nouvel utilisateur, mais il faut qu’il ait les droits SELECT, INSERT, UPDATE, DELETE, EXECUTE sur la nouvelle base créée.

Une fois la base créée, la sélectionner (dans la barre latérale gauche qui liste les tables), puis cliquer sur l’onglet « Importer ». Choisir le fichier C:\wamp\www\lms\sql\lms.sql et cliquer sur le bouton « Exécuter » :

Configurer Jorani

Normalement, la configuration par défaut de Jorani est suffisante. Cependant, si vous avez choisi un autre nom de bas de données, créé un utilisateur spécifique ou qu’un mot de passe est obligatoire pour le compte root, vous devrez modifier le contenu du fichier de configuration dans C:\wamp\www\lms\application\config\database.php avec ce qui correspond à votre environnement.

Tester les e-mails

On n’a pas toujours un serveur SMTP sous la main, aussi je vous recommande un petit utilitaire pratique : SMTP4DEV.

Avec la configuration par défaut de Jorani, vous n’avez rien d’autre à faire que de lancer l’utilitaire et Il réceptionnera les e-mails que vous pourrez visualiser à l’aide votre client e-mail préféré.

Si vous avez Python sous la main, vous pouvez également utiliser le module smtpd à l’aide de cette ligne de commande :

python -m smtpd -n -c DebuggingServer localhost:25

Les e-mails envoyés par Jorani seront alors affichés dans le terminal.

Tester l’installation

Il ne vous reste plus qu’à ouvrir votre navigateur et à accéder à la page http://localhost/lms/

L’identifiant et le mot de passe sont, à chaque fois bbalet.

Pour aller plus loin

L’étape suivante consistera à déployer Jorani sur un serveur de votre entreprise ou bien chez votre hébergeur web. L’intérêt de l’article est de vous avoir présenté les principes techniques et les prérequis à son installation. Sachez que Jorani a été conçu et testé pour être compatible avec la plupart des produits du moment (MySQL, MariaDB, Apache, nginx, PHP 5.6 ou HHVM).

Voici d’autres ressources intéressantes :

• Guide de démarrage rapide.
• Le site du projet.
• Le repository github du projet.

Cet article Tester Jorani avec WAMP sur son ordinateur est apparu en premier sur Benjamin BALET.

Connexion à Jorani par annuaire LDAP

Cet article concerne Jorani (un LMS, pour Leave Management System), un logiciel libre de gestion des congés et des heures supplémentaires. Que nous avions présenté dans un article précédent.

Principe technique

Authentification par base de données

Dans le mode de connexion normal, Jorani vérifie que l’identifiant et le mot de passe saisis dans le formulaire de connexion existent dans la base de données de Jorani (LMS).

L’occasion de rappeler que même si Jorani est hébergé sur un environnement non sécurisé (accès en HTTP et pas en HTTPS), le logiciel contient des mécanismes de sécurité empêchant des tiers de voler votre mot de passe :

• Le mot de passe est crypté à l’aide de l’algorithme BCRYPT avant d’être stocké dans la base de données. Ainsi, si quelqu’un a accès à la base de données, il ne sera pas capable d’en extraire les mots de passe.
• Lors de la phase de connexion, le mot de passe n’est pas envoyé en clair, mais l’échange du mot de passe entre le navigateur et le serveur est crypté par le protocole RSA.

Authentification par annuaire LDAP

Dans le mode de connexion LDAP, Jorani vérifie l’existence de l’identifiant dans sa base interne et s’appuie sur l’annuaire d’entreprise afin de vérifier le mot de passe saisi.

Afin de vérifier que le mot de passe est correct, Jorani tente de faire ce que l’on appelle un bind ou liaison à l’annuaire LDAP en utilisant l’identifiant de connexion ainsi que le mot de passe saisi.

Configurer Jorani

Prérequis

Information concernant l’annuaire de votre entreprise

Avant de configurer Jorani, il faudra récupérer les informations de connexion auprès de la personne administrant l’annuaire de votre entreprise ou d’un collègue de travail ayant déjà configuré un logiciel utilisant LDAP pour l’authentification des utilisateurs.

Activer le module LDAP de PHP

Avant d’utiliser LDAP, vous devez activer le module PHP de gestion des connexions LDAP.

Si Jorani est hébergé sur Internet, il est possible que votre hébergeur n’offre pas cette possibilité. Si Jorani est hébergé sur Internet et que votre annuaire d’entreprise est hébergé sur l’intranet de votre entreprise, il faut vous rapprocher de l’équipe gérant le réseau afin de vous assurer de la faisabilité technique de cette configuration.

Correspondance entre LDAP et Jorani

Pour que l’authentification fonctionne, il faut que l’identifiant stocké dans la base des utilisateurs de Jorani ait le même format que celui stocké dans l’annuaire de votre entreprise.

Par exemple « bbalet » est mon identifiant utilisateur dans Jorani, il faut aussi que cela soit mon identifiant dans LDAP. Si « bbalet » est mon login pour me connecter à Jorani, mais que mon identifiant dans l’annuaire d’entreprise est « benjamin.balet », cela ne fonctionnera pas.

Configuration de LDAP dans LMS

Dans l’emplacement d’installation, ouvrir le fichier application/config/config.php et chercher le groupe de lignes concernant la configuration de connexion par LDAP :

$config['ldap_enabled'] = FALSE;
$config['ldap_host'] = '127.0.0.1';
$config['ldap_port'] = 389;
$config['ldap_basedn'] = 'uid=%s,ou=people,dc=company,dc=com';

Afin d’activer l’authentification via LDAP dans Jorani, il faut modifier ces variables ainsi :

• ldap_enabled à TRUE
• ldap_host avec l’adresse de votre serveur LDAP.
• ldap_port avec le port de votre serveur LDAP.
• ldap_basedn en fonction de la manière dont les utilisateurs sont identifiés par l’annuaire. Il est important de ne pas supprimer les deux signes %s qui symbolisent l’emplacement du code utilisateur (ou identifiant de connexion) qui sera vérifié dans LDAP. Le contenu de cette chaîne de caractères est spécifique à votre entreprise et vous pouvez l’obtenir en contactant l’administrateur de l’annuaire LDAP de votre  entreprise.

Il existe également un mode de connexion LDAP avancé pour les cas où vos utilisateurs sont dans des endroits différents de l’annuaire.

Obtenir de l’aide

Vous pouvez demander de l’aide sur le forum des utilisateurs de Jorani, mais il sera difficile de vous assister sans avoir accès à votre annuaire LDAP. C’est pour cela qu’il faudra en premier lieu vous adresser aux administrateurs de l’annuaire de votre  entreprise et éventuellement à l’équipe réseau en cas de problèmes techniques.

Cet article Configurer l’authentification LDAP de Jorani est apparu en premier sur Benjamin BALET.

Jorani solution open source pour gérer les congés

Vous gérez une association ou une PME ? Vous avez un processus à base de formulaires papier et vous souhaitez passer en douceur à une solution informatique sans prise de tête ? Jorani est fait pour vous.  Conçu initialement pour une ONG employant environ 100 personnes et opérant dans plusieurs pays, son auteur a décidé de publier le code source sous une licence libre GPL. Ce qui veut dire que vous pouvez l’obtenir et l’installer gratuitement.

Comme vous le verrez dans les copies d’écrans, Jorani est disponible en anglais et en français. Passons maintenant en revue les points clés de la solution.

Les contrats

Dans Jorani, on peut gérer différents types de contrat avec des périodes annuelles de congés différentes. Par exemple, en France les congés courent du 1^er juin au 31 mai, mais vous pourriez gérer un autre site à l’étranger  avec des périodes différentes.

L’icône de calendrier permet – comme expliqué dans le paragraphe suivant – de définir les jours non travaillés. Tandis que l’icône de modification avancée permet de modifier les jours de congé auquel le contrat donne droit :

Jorani permet également de saisir des droits individuels d’absence pour chacun des employés. Le nombre de jours saisis pour un employé peut être négatif, ce qui permet de gérer le cas des employés arrivant en cours de route. Ou le cas de certains pays où le droit à prendre des congés s’acquiert mois par mois.

Les jours non travaillés

Jorani permet de calculer automatiquement la durée d’une demande de congés. Encore faut-il définir quels sont les jours non travaillés. L’écran reproduit ci-dessous permet de le faire au jour le jour (en cliquant sur une case du calendrier) ou de définir une série (par exemple tous les samedis).

On peut se servir de cet écran pour définir les RTT imposées (ici le 26/12 par exemple). Ou bien laisser les employés les poser.

Les jours non travaillés sont définis au niveau d’un contrat. Aussi vous pouvez gérer le cas des temps partiels à l’aide cet écran et en créant un contrat spécifique.

Les droits individuels à congés

Comme vu précédemment, rien ne vous empêche de saisir des durées négatives afin de rattraper les cas d’employés arrivés en cours d’année ou résoudre les problèmes de rattrapage de congés pris par anticipation. Dans cet exemple, le nombre de jours sera soustrait au nombre de jours accordés par le contrat. Par exemple, si mon contrat me donne droit à 20 jours de congé, je n’ai le droit qu’à 7 jours pour cette année.

C’est cette même fonctionnalité qui gère les congés individuels (maternité, paternité, congés exceptionnels, décès d’un proche, mariage, etc.).

La demande de congés

J’en viens enfin à l’écran principal de l’outil : le formulaire de demande des congés. Il était toutefois nécessaire de décrire les fonctionnalités précédentes, car elles permettent à l’outil de fonctionner correctement.

Dans cette capture d’écran, nous voyons que la durée du congé est calculée automatiquement  (grâce aux jours travaillés que nous avons définis plus tôt). Un autre point important est que l’application prévient l’utilisateur en cas de dépassement. Toutefois, rien n’interdit à l’employé de créer cette demande. Son manager pouvant la valider ou la rejeter.

Lorsque l’utilisateur crée sa demande, un e-mail est envoyé à son supérieur hiérarchique. Avec des liens pour valider ou rejeter la demande directement depuis l’email (Jorani présente aussi un écran avec la liste des demandes à examiner). Voici le processus de demande des congés :

Il existe un processus similaire de gestion des heures supplémentaires. Une fois que la demande est validée, elle vient créditer le nombre de jours de congé de récupération d’un employé. À moins que vous souhaitiez gérer ce cas différemment.

Calendriers

Jorani contient plusieurs calendriers (individuel, d’équipe, global, etc.) permettant de visualiser qui est absent. Ce qui est très pratique, surtout que l’on peut superposer l’affichage des jours non travaillés :

Les autres fonctionnalités

Voici une liste non exhaustive des autres fonctions que vous trouverez dans cet outil de gestion des congés :

• L’outil est entièrement gratuit (pas de modules payants qu’il faudrait acquérir en plus de la version gratuite).
• Les données vous appartiennent (rien n’est envoyé à un serveur tiers, tout reste sur votre serveur).
• Dans Jorani, toutes les listes présentées à l’écran sont exportables sous Excel en un clic.
• La sécurité est au cœur de la conception de Jorani. Si vous n’avez pas le droit de modifier un objet, vous ne le pourrez pas.
• Un utilisateur avec les droits RH peut modifier n’importe quelle demande.
• Jorani est très compatible. Vous pourrez l’installer sur un hébergement mutualisé, un serveur Apache ou nginx, avec MySQL ou MariaDB, avec HHVM ou n’importe quelle version de PHP 5.
• Il est très facile d’y connecter Google Analytics afin de comprendre l’utilisation qu’en font vos employés.
• Il y a une petite API pour connecter le système à des logiciels tiers.

Pour aller plus loin

J’espère que cet article vous a donné envie d’adopter Jorani. Pour plus d’information, vous pouvez :

• Essayer la démonstration en ligne : http://demo.leave-management-system.org
• Aller sur le site officiel : http://fr.jorani.org/
• Récupérer les sources sur la forge Github : https://github.com/bbalet/jorani

Contribuez !

On l’oublie souvent, mais les logiciels libres sont le fruit du travail de bénévoles qui investissent du temps et un peu d’argent dans leurs créations. Ils ont donc besoin d’un petit coup de pouce. Vous pouvez améliorer le logiciel de différentes manières :

• Envoyez vos souhaits de fonctionnalités ou déclarez les défauts via le projet Github ou le formulaire de contact du site officiel.
• Faites un don au projet.
• Traduisez Jorani dans une autre langue.
• Apportez votre pierre à l’édifice en développant une nouvelle fonctionnalité ou en améliorant le code existant.

Cet article Jorani application simple et gratuite de gestion des congés est apparu en premier sur Benjamin BALET.

Rappel concernant RSA

Voici un exemple de chiffrement partiel d’un contenu à l’aide de l’algorithme asymétrique RSA. On rappelle qu’avec RSA il y a deux clés :

• Une clé publique avec laquelle le client peut crypter des messages, mais pas les décrypter.
• Une clé privée avec laquelle le serveur peut crypter et décrypter des messages (puisqu’une clé privée RSA contient également la clé publique).

Générer les clés avec openssl

La première étape consiste à générer une paire de clé publique et privée, puis à les stocker dans votre arborescence projet. On peut bricoler quelque chose avec golang ou utiliser openssl (allez voir sur le site, il existe maintenant des versions pour tous les OS) avec les commandes suivantes :

openssl genrsa -out private.pem 1024

openssl rsa -pubout -in private.pem -out public.pem

Template et code Golang du formulaire de connexion

Puis on créera un template pour un formulaire de login. Ce template utilisera la bibliothèque jsencrypt qui est une implémentation de l’algorithme RSA en Javascript. Le principe du code est le suivant :

• A l’appel de la page, Go remplira la variable public_key avec le contenu de la clé publique stockée côté serveur (et que vous avez générée plus tôt).
• Côté client, on chiffre le mot de passe avec la clé publique et on envoie le contenu chiffré au serveur. Notez que le mot de passe en clair n’est pas transmis puisque le champ est à l’extérieur du formulaire. La bibliothèque jsencrypt se charge également d’encoder le contenu chiffré (qui est binaire) en base64 de manière à ce qu’il puisse transiter en tant que valeur du formulaire sans problème.

<!doctype html>

<html>

<head>

    <meta charset= »utf-8″>

    <title>{{.Title}}</title>

    <script src= »/js/jsencrypt.min.js »></script>

    <script src= »/js/jquery-1.10.2.min.js »></script>

</head>

<body> 

<form id= »target » action= »/send » method= »POST »>

    <label for= »User »>User:</label>

    <input type= »text » name= »User » autofocus required /><br />

    <input type= »hidden » name= »CipheredValue » id= »CipheredValue » /><br />

</form>

<label for= »Password »>Password:</label>

<input type= »password » name= »Password » id= »Password » required /><br />

<input id= »encrypt » type= »button » value= »send » />

        <script>

    var public_key = « {{printf « %s » .Value}} »;

        $(function() {

        $(‘#encrypt’).click(function() {

        var encrypt = new JSEncrypt();

        encrypt.setPublicKey(public_key);

        var encrypted = encrypt.encrypt($(‘#Password’).val());

        $(‘#CipheredValue’).val(encrypted);

        $(‘#target’).submit();

        });

    });    

    </script>

    </body>

</html>

Le gestion de la page est ultra simple puisqu’il s’agit simplement de servir le template et de remplir la variable contenant la clé publique :

type Page struct {

    Title string

    Value []byte

}

func homeHandler(w http.ResponseWriter, r *http.Request) {

    // Read the public key

    pemData, err := ioutil.ReadFile(publicKey)

    if err != nil {

        log.Fatalf(« read key file: %s », err)

    }

    var p = Page{Title: « Login », Value: pemData}

    err = templates.ExecuteTemplate(w, « home.html », p)

    if err != nil {

        http.Error(w, err.Error(), http.StatusInternalServerError)

    }

}

Décryptage du message chiffré avec RSA côté serveur

Là où les choses se compliquent, c’est pour décoder le message côté serveur. Le code est assez long parce qu’il effectue toutes les actions suivantes :

1. Lire le fichier contenu la clé privée.
2. Interpréter le format de fichier PEM et tester sa validité.
3. Décoder la clé privée.
4. Convertir le message crypté passé dans le formulaire de la base64 à du binaire.
5. Déchiffrer le message crypté (le mot de passe).

func sendHandler(w http.ResponseWriter, r *http.Request) {

     // Read the private key

    pemData, err := ioutil.ReadFile(privateKey)

    if err != nil {

        http.Error(w, err.Error(), http.StatusInternalServerError)

        return

    }

    // Extract the PEM-encoded data block

    block, _ := pem.Decode(pemData)

    if block == nil {

        http.Error(w, err.Error(), http.StatusInternalServerError)

        return

    }

    if got, want := block.Type, « RSA PRIVATE KEY »; got != want {

        http.Error(w, err.Error(), http.StatusInternalServerError)

        return

    }

    // Decode the RSA private key

    priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)

    if err != nil {

        http.Error(w, err.Error(), http.StatusInternalServerError)

        return

    }

    // Decode the Base64 into binary

    cipheredValue, err := base64.StdEncoding.DecodeString(r.FormValue(« CipheredValue »))

    if err != nil {

        http.Error(w, err.Error(), http.StatusInternalServerError)

        return

    }

    // Decrypt the data

    var out []byte

    out, err = rsa.DecryptPKCS1v15(rand.Reader, priv, cipheredValue)

    if err != nil {

        http.Error(w, err.Error(), http.StatusInternalServerError)

    }

    var p = Page{Title: « Decrypt value », Value: out}

    err = templates.ExecuteTemplate(w, « send.html », p)

    if err != nil {

        http.Error(w, err.Error(), http.StatusInternalServerError)

    }

}

Il ne vous reste plus qu’à compléter cet extrait de code avec votre gestionnaire des utilisateurs. Par exemple, en vérifiant le mot de passe avec une valeur stockée en base de données.

Cet article Chiffrement RSA partiel en golang et Javascript est apparu en premier sur Benjamin BALET.

Un exemple concret

Comme d’habitude, je me base sur OpenCart (http://www.opencart.com/), une application open source tournant sur une pile WAMP. Cette application en PHP est intéressante, parce qu’elle présente les cas d’usage les plus répandus (CRUD, recherche, liste, détail) et elle est livrée avec un jeu de données minimaliste.

Jeu de données

Il est possible d’importer dans le scénario un fichier CSV, une table ou un onglet Excel afin de l’utiliser dans l’étape d’édition du scénario. Ici, j’ai choisi de créer une liste d’identifiants d’articles différents afin d’introduire de la variation dans les données utilisées. Ce qui permet de ne pas obtenir de trop bons résultats à cause des différents caches applicatifs.

Enregistreur

HTTP Rider utilise Fiddler afin d’enregistrer tous les échanges http (seulement les requêtes GET et POST) ayant lieu sur la machine où il est utilisé. On peut définir des règles d’inclusion ou d’exclusion d’URL afin de filtrer ce qui sera enregistré (et donc rejoué plus tard lorsque l’on lancera le tir).

Éditeur de script

L’étape suivant celle de l’enregistrement permet de supprimer des requêtes que l’on aurait oublié de filtrer. On peut aussi utiliser des paramètres issus des données que l’on aurait importées précédemment. Ici je lie le paramètre « product_id » à la première colonne de mon jeu d’essai.

On notera qu’il est possible d’enregistrer le scénario (mono-script en fait).

Exécution

La dernière étape permet de lancer le tir proprement dit. On peut fixer :

• Le nombre d’utilisateurs simulés en parallèle.
• La durée du tir (Elapse time).
• La pause à effectuer entre chaque requête http (think time).
• La limite à ne pas dépasser lorsque l’on attend la réponse HTTP (puisque le timeout est une notion définie sur le navigateur des visiteurs).

On obtient alors les temps de réponse des requêtes HTTP enregistrées. L’outil ne fournit pas d’autres rapports ou de possibilités d’export que ce que vous voyez sur cet écran.

Comment est fait HTTP Rider ?

• Il est en .Net et il ne tournera que sous Windows avec le framework 4.0.
• Il se base sur le composant Fiddler (le couteau suisse indispensable du consultant en performance) pour la capture des trames HTTP. http://fiddler2.com/
• Il utilise HTML Agility pack pour manipuler les en-têtes et corps de requête http://htmlagilitypack.codeplex.com/
• Et d’autres composants open source.

Les points forts d’HTTP Rider

• Assistant graphique permettant de créer un test de charge sans prétention, mais rapidement.
• Possibilité de capturer les requêtes http depuis n’importe quel exécutable émettant des trames HTTP (merci Fiddler).
• La possibilité d’utiliser un jeu de données afin d’introduire de la variation.
• Possibilités d’inclusion et d’exclusion d’URL.

Les points faibles d’HTTP Rider

• Ne supporte que le protocole HTTP (au niveau requête ou URL-based si on le comparait à LoadRunner).
• Le code source n’est pas disponible.
• C’est un projet expérimental (l’auteur n’a visiblement pas d’intention de le continuer ou de l’ouvrir aux contributeurs).
• La dernière version date du 24/02/2012.
• Limité aux verbes GET et POST.
• Ne supporte pas les sessions TLS (HTTPS).
• Pas de reporting (cependant, je pense que ce n’est pas son positionnement).

Conclusion

HTTP Rider est un outil intéressant qui est comparable à Apache Benchmark, mais que l’on pourrait situer un cran au-dessus parce qu’il est doté d’une interface graphique permettant de faire la capture des échanges et d’avoir un résultat rapide. J’ai bien aimé la possibilité de lier un jeu de données depuis Excel en toute simplicité (encore un point fort par rapport à AB).

Attention au fait que cet outil ne permet de monter un scénario composé que d’un seul script. On peut cependant lancer plusieurs instances de l’outil sur une seule ou plusieurs machines.

Malheureusement l’outil ne va pas plus loin en termes de résultats (pas de graph de type « over time ») ou de définition du scénario (rampe, etc.). J’ai de gros doutes sur sa pérennité et il est vraiment dommage que le code source ne soit pas disponible.

En bref, si vous souhaitez faire un test de charge vite fait afin d’avoir une idée des temps de réponse sans la complexité d’un JMeter ou d’un LoadRunner, foncez avant que l’outil ne disparaisse du net.

Pour aller plus loin

• Le scénario et le jeu d’essai utilisés pour cet article sont disponibles ici.
• Lien vers la page du projet.

Cet article HTTP Rider le test de performance quick-and-dirty est apparu en premier sur Benjamin BALET.

Niveau de protocole

Si on avait à comparer avec LoadRunner, le protocole (dans le sens LoadRunner) serait HTTP (URL based). Il existe une possibilité de coder une script au niveau de l’interface (« Coded UI test » que l’on pourrait comparer au mode TruClient), mais cela est déconseillé par la documentation. Microsoft en parle comme d’une solution temporaire ou de dernier recours. A mon avis, cela ne doit pas très bien marcher ou consommer une énorme quantité de ressources système.

Enregistreur de script

Un add-in Internet Explorer permet d’enregistrer les actions de l’utilisateur d’une application web compatible avec IE. Ce qui est enregistré sont les actions effectuées au niveau du protocole HTTP (GET, POST…) et pas les actions au niveau du réseau ou utilisant un autre protocole. Par exemple, les interactions d’une applet Java en RMI ne seront pas enregistrées (si tant est que cela existe encore).

Si certaines actions n’ont pas été capturées par l’add-in, il est possible de les ajouter dans le modeleur graphique du script ou de les coder manuellement dans le code source généré (voir plus loin).

Il y a une fonctionnalité de détection des paramètres dynamiques, mais je ne l’ai jamais vu détecter quoi que ce soit durant mes tests. Elle est déclenchée suite à l’enregistrement du script ou à la demande. Elle n’est pas vraiment comparable à la fonctionnalité de corrélation automatique de LoadRunner qui a un taux de détection plus élevé.

Scripting

Une fois le script enregistré, on a accès à un modeleur (je l’appellerai comme ça dans la suite de l’article afin de le différencier d’un script codé) qui permet de modifier le script graphiquement. Par exemple, coupler les paramètres http à une source de données :

On peut convertir ce script en code C# ou Visual Basic (selon la nature du projet .Net). Ce qui ouvre toutes les possibilités du Framework .Net. Voici un court extrait de code:

WebTestRequest request2 = new WebTestRequest("http://localhost/opencart/index.php");
request2.Headers.Add(new WebTestRequestHeader("Referer", "http://localhost/opencart/"));
request2.QueryStringParameters.Add("route", "product/category", false, false);
request2.QueryStringParameters.Add("path", "20_26", false, false);
yield return request2;
request2 = null;

SLA et transactions

Ce qu’il est possible de faire:

• Il est possible de grouper une ou plusieurs requêtes HTTP au sein de transactions.
• Il est possible de définir des temps de réponse attendus globaux ou au niveau des requêtes.
• Il n’est pas possible de définir des SLA par palier de charge ou sur d’autres objectifs.

Dans cet exemple d’exécution, on remarque un dépassement des objectifs :

Paramètres / Jeu d’essai

Il est possible de définir une source de données et de l’utiliser dans le modeleur ou dans le code. Cependant, cette fonctionnalité n’est pas comparable à celle de LoadRunner. Ainsi il n’est pas possible graphiquement :

• D’asservir deux variables (« same line as »).
• D’allouer des blocs de données par utilisateur virtuel.
• De définir des règles de consommation des données (choix d’une ligne au hasard, consommation unique, arrêter en fin de table…).

Tous ces cas d’usage devront être codés (voir plus loin avec les possibilités d’extension).

Think time

Les temps de pause sont liés aux requêtes HTTP et ils se configurent donc au niveau de la requête. Par exemple dans le code généré suivant :

WebTestRequest request1 = new WebTestRequest("http://localhost/opencart/index.php");
request1.ThinkTime = 8;

On peut ensuite définir au niveau du scénario ce que l’on fera de ces temps d’attente (« as recorded », etc.).

Possibilités d’extension

Comme nous l’avons vu précédemment, les scripts peuvent être convertis en code .Net. On peut avoir accès à une API de test de performance depuis ce code. Ce qui permet de gérer plus finement les paramètres ou les différents objets de test (requêtes HTTP, règle de validation ou d’extraction…). Il existe deux API :

• Web Performance Test API : http://msdn.microsoft.com/en-us/library/ms182558(v=vs.120).aspx
• Load Test API : http://msdn.microsoft.com/en-us/library/ms182605(v=vs.120).aspx

Si vous venez de LoadRunner, ce qu’il faut comprendre, c’est que les deux modèles sont cloisonnés (Script : Web Performance Test API et Scénario : Load Test API). Ainsi, on ne peut pas aisément obtenir une information contextuelle au tir dans une instance de script (par exemple, le numéro d’itération dans le tir ou est-on dans un contexte de tir ou pas – e.g. dans LR en jouant sur la valeur de « Group Name »). Il faut coder !

Il y a deux possibilités de création de plugin :

• Load Test Plug-In (http://msdn.microsoft.com/en-us/library/ms243153(v=vs.120).aspx): Pour déclencher des actions à certains évènements du tir (début, fin, dépassement de SLA…). Un exemple simple serait de déclencher des actions en début ou en fin de tir.
• Web Performance Test Plug-In (http://msdn.microsoft.com/en-us/library/ms243191(v=vs.120).aspx): Pour étendre les capacités du modeleur graphique (personnaliser le script sans coder). Ou pour créer du code réutilisable. Un exemple simple serait de générer un nombre aléatoire afin de l’utiliser en tant que paramètre.

Collecte des indicateurs

Cette fonctionnalité est clairement orientée Microsoft. Ainsi, elle est seulement capable de collecter les indicateurs via WMI (ceux qui sont visibles depuis perfmon.exe). Elle ne supporte pas la collecte via SNMP ou rpc.rstatd. Cependant, il y aurait des possibilités (http://www.networkcircus.com/articles/20090606.html) que je n’ai pas testées :

• Le projet Open Pegassus a développé un utilitaire WMI Mapper https://collaboration.opengroup.org/pegasus/
• Il y aurait un client WMI pour Linux http://www.krenger.ch/blog/wmi-commands-from-linux/
• Créer un indicateur personnalisé, comme expliqué dans le paragraphe suivant.

D’un autre côté, cette intégration au monde Microsoft permet de bénéficier d’indicateurs par défaut sur les outils maison (IIS, SQL Server…).

Créer un indicateur personnalisé

Comme expliqué dans le paragraphe précédent, hormis les indicateurs de comportement du test de charge, tous les autres indicateurs ne peuvent provenir que de WMI. Si vous souhaitez créer des indicateurs personnalisés (issu d’une application, d’une extraction, etc.) il faut donc créer une nouvelle section et de nouveaux indicateurs WMI. Une solution est fournie ici http://stackoverflow.com/a/17117685

Scénario

Les possibilités sont à peu près les mêmes qu’avec les outils concurrents. Il existe une fonctionnalité de mix des types de réseau (débit) et des navigateurs (user-agent). Les notions de pacing, durée (ou nombre d’itérations) et de rampe sont présentes par contre les utilisateurs virtuels sont arrêtés d’un coup.

On peut également diminuer ou augmenter la fréquence d’échantillonnage des indicateurs collectés. Ce qui est sympa si on souhaite avoir une granularité plus fine ou si on veut, au contraire, limiter le stress sur les machines testées ou les agents (i.e. les  injecteurs). En effet, certains indicateurs sont chers à obtenir en termes de ressources.

Résultats et Reporting

L’outil génère les graphiques classiques des tests de charge (temps de réponse moyen, taux d’erreurs, hits/s…) ainsi que les métriques systèmes via WMI. On peut même faire des calculs d’estimation de la répartition temps serveur / temps réseau, parce qu’il expose les indicateurs :

• Temps réseau : Avg. Connection Wait Time
• Temps réseau (début du transfert) : Avg. First Byte Time
• Temps global (requête + transfert) : Avg. Response Time

Exports Excel

À condition que vous ayez lancé VS2013 en tant qu’administrateur, l’outil est capable de générer deux types de rapport Excel :

• Un rapport de tendance (suivi des performances à travers plusieurs tirs). Un exemple ici.
• Un rapport de comparaison entre différents tirs. Un exemple ici.

Je regrette que les graphiques du type « Over time » (comportement du système durant le tir) ne soit pas directement exportables sous la forme dans laquelle ils sont consultables dans VS2013 (il faut exporter les données du graph, puis reconstruire le graphique depuis Excel). Par exemple, le nombre de hits/s pour savoir si le système s’effondre ou pas :

Infrastructure de test

Il est possible de déporter l’exécution des différents composants sur plusieurs machines :

• Le contrôleur est le composant qui est le chef d’orchestre du tir. Il est aussi chargé de collecter tous les indicateurs et évènements du tir.
• Les « Tests agents » (qu’on appelle injecteur ou Load Generators sur d’autres outils) sont en charge d’exécuter les scripts (ou tests) qui génèrent de la charge sur l’application à tester.

Par défaut, les indicateurs de base (CPU, mémoire réellement disponible) sont ramenés dans le rapport du tir. Ainsi, on peut savoir si l’infrastructure de test tenait la route.

Cloud-based performance testing

Avec l’édition Visual Studio 2013 Ultimate MSDN, il serait possible de tester les sites Internet depuis le cloud et cela serait inclut dans le prix. Voir http://tfs.visualstudio.com/en-us/learn/load-testing

Cependant, il n’y a pas encore assez d’informations sur les éventuels coûts directs (et cachés) et les limites du système lorsque l’on sortira de la phase de Preview. En tout cas, les rapports sont moins riches que lors d’une exécution dans un intranet. Sont absentes par exemple les données système (CPU, mémoire…) ou les données avancées sur le réseau (temps de connexion, premier octet dans le buffer…).

Conclusion

Cet outil ne serait disponible qu’avec Visual Studio 2013 Ultimate MSDN (pour information, le prix public de Visual Studio 2012 Ultimate était de 16 944 €). Il n’y a pas de limite quant au nombre d’utilisateurs simulés (en termes de licence), contrairement aux autres outils de tests de charge où le coût peut être fonction du protocole utilisé (ici il n’y a que le protocole web) et/ou du nombre d’utilisateurs simulés.

Il est difficile de situer l’outil par rapport à la concurrence. Il est plus simple que JMeter (ou tsung). Il supporte moins de protocoles que JMeter, mais il est plus puissant si le système sous test est dans le monde Microsoft. Par contre, il n’est pas encore à la hauteur des solutions propriétaires spécialisées comme LoadRunner ou Borland/Microfocus.

Pour aller plus loin

• Le point d’entrée de la documentation.
• Télécharger la Preview de Visual Studio 2013.

Cet article Test de performance avec Visual Studio 2013 Ultimate est apparu en premier sur Benjamin BALET.

Alors que l’accessoire officiel de rechargement par induction se fait attendre sur le marché français, Maxell a sorti une tablette de rechargement par induction (sans contact ni branchement) compatible avec le nouveau Google Nexus 4. Je l’ai testée pour vous.

Pas besoin d’adaptateur ou de combine

Le principe de rechargement avec une tablette à induction n’est pas nouveau, mais il faut faire attention car beaucoup de solutions reposent sur l’utilisation d’une double coque (qui n’est souvent pas fournie). Dans le cas de la tablette Maxell, pas de double coque : elle est compatible avec le Nexus 4 et il suffit de poser le mobile sur la tablette pour que le chargement de la batterie commence.

Oubliez aussi les tentatives de rechargement avec la plaque à induction de votre cuisinière : ça peut marcher, mais ça peut aussi détruire votre téléphone portable.

Compatible avec les coques de protection

Il ne vous a pas échappé que mon mobile est protégé par une coque en silicone. Il n’est pas nécessaire de la retirer pour recharger le téléphone portable et les coques de protection n’allogent pas la durée de chargement.

Prix comparable avec l’accessoire officiel

On attend encore la disponibilité sur le marché français, mais le prix devrait se situer dans les 60€ (Le prix est de 59USD aux USA auquel il faut ajouter la TVA). Le tapis de rechargement par induction est disponible sur Amazon. Voici également un lien vers la coque de protection si elle vous a plu (et une variante du même genre) :

Je l’ai depuis plusieurs mois et j’en suis totalement satisfait.

Cet article Une tablette de rechargement QI compatible avec le Google Nexus 4 est apparu en premier sur Benjamin BALET.

Introduction

Disons d’emblée que je ne suis pas trop fan de l’approche. Je préfère gérer la traduction côté serveur pour plusieurs raisons :

• Il y a plus d’outils (par exemple poedit) et de pratiques (comprendre plus d’exemples et de retour d’expérience) avec l’approche côté serveur.
• Comme nous allons le voir plus loin, la libraire a besoin d’un serveur HTTP, elle ne peut pas être utilisée dans un projet 100% statique (par exemple un projet de type CD-ROM).
• L’approche avec gettext est plus ou moins devenue standard. Mais pour l’instant HTML5 ne propose pas de solution de traduction standard du code HTML statique.

Pourquoi diantre utiliser une telle bibliothèque (N’hésitez pas à commenter ce billet avec vos propres idées) ?

• Votre hébergeur vous fait payer le temps d’exécution, mais pas le trafic, ni le temps http statique (les GET de ressources statiques sont gratuites).
• Vous souhaitez une implémentation 100% AJAX sans code côté serveur.
• Pour une raison ou pour une autre de logique, la traduction n’est pas évidente à réaliser côté serveur et doit se faire côté client.

Exemple d’intégration

Organisation des fichiers

Par défaut, la bibliothèque – après avoir déterminé la langue de l’utilisateur – enverra une requête HTTP pour récupérer un fichier de ressource de traduction en JSON. Votre projet doit contenir un répertoire « locales », puis un répertoire par langue. Dans ce répertoire il faut déposer un fichier « translation.json » contenant les traductions. Vous pouvez créer un répertoire « dev » dans le répertoire « locales ». Ce répertoire contiendrait le(s) fichier(s) de traduction par défaut (si la langue de l’utilisateur n’est pas traduite). Personnellement, je préfère utiliser le paramètre fallbackLng afin de préciser explicitement une langue par défaut.

Bien sûr, la bibliothèque contient de nombreuses options vous permettant de modifier l’emplacement de ces fichiers. On peut aussi séparer les traductions dans des fichiers JSON différents. I18next permet, en effet, de raisonner en namespaces. Ce qui permet de regrouper les objets (boutons, labels…) dans un même fichier ou de découper les écrans de l’application en domaines. Tout dépend de la nature et du contexte de votre projet.

Exemple de fichier de traduction

On peut organiser le fichier de ressource de traduction en classant les clés de traduction sous la forme d’une arborescence. Ça tombe bien, JSON le permet et la finalité est quand même de traduire des éléments innerText situé quelque part dans le DOM d’une page web.

Bien entendu l’arborescence de la clé de traduction (dans le fichier JSON) doit se retrouver dans la valeur de l’attribut data-i18n. Par exemple, la valeur de l’attribut data-i18n (voir plus bas, l’exemple de codeHTML/ Javascript) « nav.home » renvoie à la clé de traduction « nav » : { « home » : « … »}.

Code Javascript minimal

I18next n’a pas besoin de jQuery, mais si jQuery est chargée avant, I18next est augmenté des fonctionnalités de jQuery. Ce qui est quand même plus sympa pour sélectionner des éléments du DOM.

On comprend que la bibliothèque va écraser le contenu innerText avec le contenu du fichier JSON à chaque fois qu’elle trouve une correspondance. Donc et pas soucis de clarté, le fichier HTMl peut être chargé avec des labels par défaut qui seront ensuite traduits par i18next.

Principe de fonctionnement

Processus de détermination de la langue

La bibliothèque tente de déterminer la langue de l’utilisateur dans l’ordre suivant :

1. La langue est explicitement passée en paramètre de l’initialisation de la bibliothèque
2. La page en cours contient le code langage/pays dans le paramètre (?setLng=fr-FR).
3. Il y a un cookie (i18next) contenant le code langage/pays.
4. Langue définie dans les préférences utilisateur du navigateur.

Ensuite et en ce qui concerne le chargement des ressources, l’ordre suivant est respecté :

1. i18next essaye de charger un fichier JSON contenu dans un répertoire nommé avec le code langage/pays (par exemple, « fr_FR » pour le français parlé en France).
2. Essayer de charger un fichier JSON contenu dans un répertoire nommé avec le code langage seulement (par exemple, « fr » pour le français).
3. Si aucun fichier n’est trouvé, essayer de charger le fichier dans le répertoire nommé selon la variable fallbackLng ou qui s’appelle « dev ».

Chargement des ressources de traduction

Le chargement est asynchrone, donc la bibliothèque ne peut pas être utilisée en local pour un contenu statique. Il faut un serveur web. Il n’est cependant pas nécessaire d’avoir du code côté serveur (en PHP, par exemple). La librairie se contenant de faire un HTTP GET (chargement Ajax, via requête HTTP).

L’aspect asynchrone de la bibliothèque fait que l’on ne peut appeler les fonctions de traduction qu’une fois les ressources chargées (après l’appel Ajax). Il faut passer par une fonction de callback comme dans cet exemple :

i18n.init(function(t) {

alert(i18n.t("app.name"));

});

On peut coupler l’utilisation de la librairie à jQuery pour la fonctionnalité de sélecteur (c.-à-d. sélectionner d’un coup tous les éléments d’une classe donnée ou d’un type donné…). Comme avec cet extrait de code où l’on demande la traduction de tous les éléments de classe « nav » :

$(".nav").i18n();

Autres informations

• La bibliothèque gère les formes plurielles.
• On peut brancher une fonction de post processing pour une traduction.
• On peut utiliser des formateurs de texte (sprintf, un peu en lien avec le point précédent).
• Il est possible de faire de la substitution de variable (par exemple : « il y a __nbePommes__ pommes ») sans utiliser sprintf.
• On peut stocker une valeur sur plusieurs lignes dans le fichier de ressource en JSON.
• RTFM pour le reste des fonctions.

Alternatives

• Jed qui se réclame proche de Gettext : http://slexaxton.github.com/Jed/
• Le toolkit Dojo contient un module i18n : http://dojotoolkit.org/reference-guide/1.8/dojo/i18n.html
• Jsperanto : https://github.com/jpjoyal/jsperanto

Liens utiles

• Récupérer mon projet exemple en cliquant ici.
• Téléchargement et documentation (en anglais) : http://jamuhl.github.com/i18next/index.html
• Intégration avec Express et Jade (en anglais) : http://rbeere.tumblr.com/post/41212250036/internationalization-with-express-jade-and
• Intégration avec Backbone.js (en anglais) : http://pedromadias.wordpress.com/2013/01/27/backbone-js-and-i18n/

Cet article Introduction à i18next la traduction côté client est apparu en premier sur Benjamin BALET.

Cet article s’adresse à des utilisateurs avancés ayant une bonne expérience avec Linux, mais ne pratiquant pas tous les jours la compilation du kernel. Je ne suis pas responsable des mauvais traitements que vous infligerez à votre NAS et du mal de crâne causé par toute compilation d’un noyau Linux.

En synthèse, la marche à suivre sera la suivante :

1. Maîtriser certaines manipulations sur le NAS (Telnet, SSH).
2. Obtenir la toolchain (qui sert à compiler des logiciels pour le NAS, mais depuis un autre PC Linux).
3. Obtenir le code source des applications du Synology.
4. Configurer l’environnement du PC Linux qui servira à la compilation. Régler les paramètres de compilation du noyau, compiler et installer.

Avant toute chose

Il faut posséder une machine qui tourne sous Linux pour effectuer les manipulations décrites dans ce post. Elle peut être virtuelle (avec VMWare ou Virtual Box), mais cela ne marchera pas avec CygWin, ni avec Visual Studio ou MinGW qui ne savent pas produire des exécutables au format ELF.

Les fondamentaux

La lecture de ce billet nécessite en pré-requis fondamental :

• Savoir utiliser SSH ou telnet avec son Synology.
• Savoir installer des composants additionnel sur le Synology.
• Vous pouvez vous rafraîchir la mémoire sur la cross-compilation.

Le modèle de CPU

Il faut connaître la famille de processeur qui équipe votre Synology à l’aide de cette page qui donne la correspondance. Ne pas confondre famille de processeur et modèle. Par exemple, mon PC est équipé d’un Intel Q6600 (le modèle), mais la famille de CPU est soit i686 ou x86_64 (selon si on souhaite faire une compilation 32bits ou 64bits). Il en va de même pour les Synology. Je suis l’heureux possesseur d’un DS211j équipé d’un Feroceon (le modèle), mais la famille du CPU est Marvell Kirkwood mv6281. Gardez cette info pour la partie compilation du Kernel, que l’on verra en fin d’article.

La version de Linux du Syno

Connectez-vous sur le Synology et utilisez la commande uname -r qui devrait renvoyer par exemple 2.6.32.12. Cela sera utile pour plus tard.

Obtention de la toolchain

Rendez-vous sur Sourceforge pour obtenir la toolchain. Il s’agit d’un ensemble d’outils permettant de compiler un logiciel pour qu’il soit exécuté sur le Synology. La toolchain ne s’installe pas sur le NAS, mais sur un ordinateur Linux. Le fait de compiler des sources sur un système (Linux), alors que l’exécutable produit tournera sur un autre système (le NAS Synology) s’appelle la compilation croisée (ou cross-compilation an anglais).

Dans mon cas, comme la famille de CPU de mon NAS est de type Marvell 628x et que la version de Linux est la 2.6.32.12 ; j’ai cliqué sur ce lien : http://sourceforge.net/projects/dsgpl/files/DSM%203.1%20Tool%20Chains/Marvell%2088F628x%20Linux%202.6.32/ pour obtenir l’archive gcc421_glibc25_88f628x.tgz.

Toujours sur l’ordinateur Linux, décompressez la toolchain dans /usr/local/ avec, par exemple, la commande tar zxpf gcc421_glibc25_88f6281.tgz –C /usr/local/

Obtention des sources du Synology

Le code source des applications open source composant le synology (noyau Linux, php, Apache, …) est disponible sur Sourceforge ainsi que la configuration utilisée par les développeurs pour compiler le noyau. Tout ceci va nous faciliter la tâche.

Dans mon cas, comme la famille de CPU de mon NAS est de type Marvell 628x et que la version de Linux est la 2.6.32.12 ; j’ai cliqué sur ce lien : http://sourceforge.net/projects/dsgpl/files/Synology%20NAS%20GPL%20Source/1594branch/synogpl-1594b-6281.tbz/download pour obtenir l’archive synogpl-1594b-6281.tbz que j’ai décompressé dans un répertoire quelconque (rappel : tar zxpf).

Compilation du noyau du Syno

Préparation de l’environnement

Sur la machine Linux sur laquelle vous allez compiler, ouvrez un terminal et préparez l’environnement de compilation en positionnant différentes variables système  avec ces commandes (à adapter en fonction de la toolchain que vous avez téléchargé. Si votre NAS est basé sur une architecture PowerPC, il faudra remplacer arm-none-linux-gnueabi par powerpc-linux-gnuspe) :

Compilation du kernel

Allez dans le répertoire dans lequel vous avez décompressé les fichiers sources du Synology, plus précisément dans le sous-répertoire source/linux-2.6.32 (à adapter en fonction de ce que vous a donné la commande uname -r).

Il faut configurer les options de compilation du kernel (nom anglais pour noyau de l’OS) en fonction du modèle de  processeur qui équipe votre NAS. il suffit de copier le fichier configuration du processeur à la racine de la source du kernel cela donne :

cp /mon_rep/source/linux-2.6.32/synoconfigs/88f6281 /mon_rep/source/linux-2.6.32/.config

Dans le répertoire source/linux-2.6.32, lancez les commandes suivantes :

make oldconfig

make menuconfig

Une interface graphique va s’ouvrir dans laquelle vous choisissez différentes options de compilation et les drivers à compiler. Par exemple, pour une webcam, activez les options (la suite de la configuration dépend du modèle) :

1. Devices Drivers
2. Multimedia Support
3. …

Puis on lance la compilation avec les commandes :

make dep

make modules

La compilation peut être accéléré si vous avez un CPU multi-coeurs avec (pour 4 coeurs) la commande :

make modules -j 4

Et après ?

Vous trouverez les drivers sous la forme de fichiers .ko dans le sous-répertoire drivers. Par exemple, pour le dirver Universal Video Class (uvcvideo.ko) dans drivers/media/video/.

Le module obtenu doit être chargé en mémoire afin de pouvoir piloter votre périphérique. on peut utiliser la commande insmod à cet effet. insmod fait partie du paquet module-init-tools (voir ce post pour l’installer avec ipkg) tout comme :

• lsmod – pour lister les modules chargés
• rmmod – pour supprimer un module de la mémoire.

On peut aussi le charger de manière permanente en copiant les fichiers ko dans /lib/modules/$(uname -r)/kernel/drivers/ et l’ajouter au fichier /etc/modules

Un exemple concret de ces commandes est à suivre dans un billet qui explique comment compiler et installer un driver de webcam USB.

Sources documentaires

• Lien vers le fichier PDF officiel (de Synology, anglais).

Cet article Compiler un driver pour le Synology est apparu en premier sur Benjamin BALET.