1. Introduction

Iperf est un des outils indispensables pour tout administrateur réseau qui se respecte. En effet, ce logiciel de mesure de performance réseau, disponible sur de nombreuses plateformes (Linux, BSD, Mac, Windows…) se présente sous la forme d'une ligne de commande à exécuter sur deux machines disposées aux extrémités du réseau à tester.

Iperf fonctionne comme un client/serveur selon le diagramme suivant :

Image non disponible

Iperf doit être lancé sur deux machines se trouvant de part et d'autre du réseau à tester. La première machine lance Iperf en « mode serveur » (avec l'option -s), la seconde en « mode client » (option -c). Par défaut le test réseau se fait en utilisant le protocole TCP (mais il est également possible d'utiliser le mode UDP avec l'option -u).

Nous allons commencer par installer Iperf en utilisant la commande suivante (sous Fedora) :

 
Sélectionnez
# yum install iperf

Pour les autres systèmes d'exploitation, vous pouvez vous rendre sur cette page.

1-1. Premier exemple d'utilisation

Ensuite, sur une des deux machines de test, nous allons lancer le serveur grâce à la commande suivante :

 
Sélectionnez
# iperf -s

Sur le client, il ne reste plus qu'à lancer le client en précisant l'adresse du serveur :

 
Sélectionnez
# iperf -c <adresse IP du serveur>

Vous devriez avoir le rapport qui s'affiche après dix secondes de test.

 
Sélectionnez
------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 65.0 KByte (default)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 50675 connected with 192.168.29.1 port 5001
[ ID] Interval Transfer Bandwidth
[ 3] 0.0-10.0 sec 110 MBytes 92.6 Mbits/sec

Avec les options par défaut, le test est fait en TCP sur une durée de dix secondes. Sur un réseau local vous devriez donc obtenir une valeur proche de la capacité de commutation de vos équipements (par exemple 92.6 Mbit/sec qui est une valeur proche de 100 Mbit/sec).

Pour afficher des rapports intermédiaires (par exemple toutes les secondes), il suffit d'ajouter l'option (-i 1) sur le client et/ou le serveur.

 
Sélectionnez
# iperf -s -i 1
------------------------------------------------------------
Server listening on TCP port 5001
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 50692
[ 6] 0.0- 1.0 sec 10.1 MBytes 84.8 Mbits/sec
[ 6] 1.0- 2.0 sec 11.1 MBytes 93.0 Mbits/sec
[ 6] 2.0- 3.0 sec 11.2 MBytes 93.8 Mbits/sec
[ 6] 3.0- 4.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 4.0- 5.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 5.0- 6.0 sec 11.2 MBytes 93.8 Mbits/sec
[ 6] 6.0- 7.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 7.0- 8.0 sec 11.2 MBytes 93.8 Mbits/sec
[ 6] 8.0- 9.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 9.0-10.0 sec 11.2 MBytes 93.9 Mbits/sec
[ 6] 0.0-10.0 sec 111 MBytes 92.9 Mbits/sec

Une autre option de base est (-t) qui permet de fixer au niveau du client le temps du test (en secondes). Par exemple pour effectuer un test pendant une minute :

 
Sélectionnez
# ipert -c <adresse IP du serveur> -t 60

1-2. Exemple de test en utilisant le protocole UDP

Iperf permet également de générer un trafic de type UDP (-u). Dans ce cas-là, il faut penser à fixer la bande passante cible (contrairement au protocole TCP, UDP ne peut pas faire de contrôle de flux). On utilise pour cela l'argument -b au niveau du client :

Sur le serveur :

 
Sélectionnez
# iperf -s -u

Sur le client :

 
Sélectionnez
# ipert -c <adresse IP du serveur> -u -b 512k

Ce couple de commandes va générer un test avec un flux réseau UDP de 512 kbit/sec.

Comme vous pouvez le voir, Iperf est également un bon outil de génération de flux. Je l'ai déjà testé pour générer un flux UDP constant pendant plusieurs jours.

1-3. Exemple de test en multicast (UDP)

Iperf peut fonctionner en mode multicast (-B). Il faut le lancer de la manière suivante :

Sur le serveur :

 
Sélectionnez
# iperf -s -u -B 226.10.11.12

Sur le/les clients :

 
Sélectionnez
# iperf -c 226.10.11.12 -u -T 32 -b 512k

Ce couple de commandes génère un flux multicast UDP (sur l'adresse 226.10.11.12, avec un TTL de 32) de 512 kbit/sec.

1-4. Autres options

Nouveau : les paragraphes suivants donneront une description des options avancées de Iperf.

Et bien entendu, il reste la fameuse commande :

 
Sélectionnez
# iperf --help

…pour avoir la liste complète des options. Si vous avez des questions, n'hésitez pas !

2. Iperf : des exemples…

Nous commençons l'année 2008 avec un billet regroupant des exemples d'utilisation d'IPerf, l'outil en ligne de commande indispensable pour tester un réseau informatique.

Pour rappel, IPerf est un logiciel client/serveur, il faut donc deux machines positionnées aux deux extrémités du réseau à tester pour fonctionner (pour l'installation et une rapide introduction, vous pouvez consulter ce billet).

Dans les exemples ci-dessous, nous allons considérer que nous allons utiliser deux machines nommées C (avec comme adresse IP : IPC) et S (avec comme adresse IP : IPS).

2-1. Exemple pour mesurer la bande passante disponible entre S et C

Attention, cette méthode mesure la bande passante au moment du test. Ce dernier dure par défaut dix secondes et utilise le protocole TCP sur le port 5001.

 
Sélectionnez
Sur la machine S : # iperf -s
Sur la machine C : # iperf -c IPS

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Server listening on TCP port 5001TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 54334
[ 6] 0.0-10.0 sec 112 MBytes 93.7 Mbits/sec

2-2. Exemple pour générer un débit réseau entre C et S

On génère ici un flux en utilisant le protocole UDP et en fixant la bande passante à 1 Megabit par seconde. Le test dure par défaut dix secondes.

Il est possible de choisir l'unité de mesure de débit avec l'option -b et en collant les lettres suivantes aux débits :

  • b : bits par seconde ;
  • k : kilobits par seconde ;
  • m : mégabits par seconde ;
  • g : gigabits par seconde.

Pour un débit en octets par seconde, il faut utiliser ces lettres en majuscules)

 
Sélectionnez
Sur la machine S : # iperf -s -u
Sur la machine C : # iperf -c IPS -u -b 4m

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Server listening on UDP port 5001
Receiving 1470 byte datagrams
UDP buffer size: 41.1 KByte (default)
------------------------------------------------------------
[ 5] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 49617
[ 5] 0.0-10.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ 3403 (0%)

2-3. Exemple pour générer un débit réseau entre C et S pendant dix heures

Il peut être utile de générer un flux réseau plus long pour tester par exemple une liaison Internet pendant les heures d'utilisation. Nous allons donc utiliser l'option -t pour fixer la durée du test précédent à dix heures (10*3600=36000 secondes).

 
Sélectionnez
Sur la machine S : # iperf -s -u
Sur la machine C : # iperf -c IPS -u -b 4m -t 36000

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Server listening on UDP port 5001
Receiving 1470 byte datagrams
UDP buffer size: 41.1 KByte (default)
------------------------------------------------------------
[ 5] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 49617
[ 5] 0.0-36000.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ 999403 (0%)

Il est également possible d'ajouter l'option -i 3600 pour avoir un rapport intermédiaire toutes les heures (1*3600=3600 secondes).

 
Sélectionnez
Sur la machine S : # iperf -s -u
Sur la machine C : # iperf -c IPS -u -b 4m -t 3600

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Server listening on UDP port 5001
Receiving 1470 byte datagrams
UDP buffer size: 41.1 KByte (default)
------------------------------------------------------------
[ 5] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 49617
[ 5] 0.0-3600.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ - (0%)
[ 5] 3600.0-7200.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ - (0%)...
[ 5] 0.0-36000.0 sec 4.77 MBytes 4.00 Mbits/sec 0.066 ms 0/ 999403 (0%)

2-4. Exemple pour générer deux flux réseau entre S et C

Il est parfois utile de générer plusieurs flux UDP simultanément pour simuler une application. IPerf permet cela grâce à l'option -P et en donnant le nombre de flux à générer. L'exemple suivant génère quatre flux TCP entre S et C (simulation d'un serveur Web par exemple).

 
Sélectionnez
Sur la machine S : # iperf -s
Sur la machine C : # iperf -c IPS -P 4

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Server listening on TCP port 5001
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64978
[ 7] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64979
[ 8] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64980
[ 9] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 64981
[ 7] 0.0-10.0 sec 28.0 MBytes 23.5 Mbits/sec
[ 8] 0.0-10.0 sec 28.0 MBytes 23.4 Mbits/sec
[ 9] 0.0-10.0 sec 28.1 MBytes 23.5 Mbits/sec
[ 6] 0.0-10.0 sec 28.1 MBytes 23.5 Mbits/sec
[SUM] 0.0-10.0 sec 112 MBytes 93.8 Mbits/sec

2-5. Exemple pour optimiser une connexion TCP entre S et C

Le protocole TCP, bien que capable de s'adapter aux réseaux large bande, a été conçu lorsque les débits étaient beaucoup moins importants. Les valeurs par défaut des fenêtres TCP (taille des paquets envoyés dans des trames TCP) ne sont pas forcément adaptées aux réseaux actuels. IPerf permet de jouer avec la taille de ces fenêtres avec l'option -w. L'exemple suivant génère un flux TCP avec une taille de fenêtre de 130 kilooctets.

 
Sélectionnez
Sur la machine S : # iperf -s
Sur la machine C : # iperf -c IPS -w 128k

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 128 KByte (WARNING: requested 130 KByte)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 65066 connected with 192.168.29.1 port 5001
[ 3] 0.0-10.0 sec 112 MBytes 93.5 Mbits/sec

2-6. Exemple pour découvrir la taille du MTU entre S et C

Le MTU est la taille maximale du paquet pouvant être transmis sur la couche réseau sans être segmenté. La découverte de cette valeur peut être utile à l'optimisation de votre réseau et des applications qui tournent dessus. IPerf permet d'obtenir cette valeur grâce à l'option -m (à lancer sur le serveur).

 
Sélectionnez
Sur la machine S : # iperf -s -m
Sur la machine C : # iperf -c IPS

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 65066 connected with 192.168.29.1 port 5001
[ 3] 0.0-10.0 sec 112 MBytes 93.5 Mbits/sec[ 3] MSS size 1448 bytes (MTU 1500 bytes, ethernet)

2-7. Exemple pour tester un flux de type VoIP entre C et S

Les paquets de type voix sur IP ont les caractéristiques suivantes : protocole UDp et taille des paquets petites (bien inférieures au MTU). Le meilleur moyen de tester un flux de type VoIP avec IPerf est d'utiliser les options -l (taille du datagram) et -w (taille maximale du buffer recevant les datagras) en fixant une valeur de datagram inférieure à celle du buffer.

 
Sélectionnez
Sur la machine S : # iperf -s -u -l 32 -w 128k -i 1
Sur la machine C : # iperf -c IPS -u -b 1m -l 32 -w 128k

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Server listening on UDP port 5001
Receiving 32 byte datagrams
UDP buffer size: 128 KByte
------------------------------------------------------------
[ 3] local 192.168.29.157 port 5001 connected with 192.168.29.125 port 32778
[ 3] 0.0- 1.0 sec 96.0 KBytes 786 Kbits/sec 0.003 ms 0/ 3 (0%)
[ 3] 1.0- 2.0 sec 128 KBytes 1.05 Mbits/sec 0.008 ms 0/ 4 (0%)
[ 3] 2.0- 3.0 sec 128 KBytes 1.05 Mbits/sec 0.017 ms 0/ 4 (0%)
[ 3] 3.0- 4.0 sec 128 KBytes 1.05 Mbits/sec 0.021 ms 0/ 4 (0%)
[ 3] 4.0- 5.0 sec 128 KBytes 1.05 Mbits/sec 0.023 ms 0/ 4 (0%)
[ 3] 5.0- 6.0 sec 96.0 KBytes 786 Kbits/sec 0.022 ms 0/ 3 (0%)
[ 3] 6.0- 7.0 sec 128 KBytes 1.05 Mbits/sec 0.152 ms 0/ 4 (0%)
[ 3] 7.0- 8.0 sec 128 KBytes 1.05 Mbits/sec 0.142 ms 0/ 4 (0%)
[ 3] 8.0- 9.0 sec 128 KBytes 1.05 Mbits/sec 0.115 ms 0/ 4 (0%)
[ 3] 9.0-10.0 sec 128 KBytes 1.05 Mbits/sec 0.098 ms 0/ 4 (0%)
[ 3] 0.0-10.5 sec 1.25 MBytes 1.00 Mbits/sec 0.116 ms 0/ 40 (0%)

Remarque : bien que Iperf soit disponible sur de nombreuses plates-formes (Linux, BSD, Mac, Windows), l'option -l ne fonctionne pas toujours quand vous utilisez des OS différents entre le client et le serveur.

2-8. Exemple pour utiliser IPerf sur un port différent

Par défaut, Iperf utilise le numéro de port 5001 (TCP et/ou UDP). Selon votre configuration (notamment au niveau des ACL des routeurs/firewalls), il peut être utile d'utiliser un autre port, pour cela, il faut passer par l'option -p. L'exemple suivant permet de générer un flux réseau TCP entre S et C sur le port 80 (port Web standard).

 
Sélectionnez
Sur la machine S : # iperf -s -p 80
Sur la machine C : # iperf -c IPS -p 80

Résultat (à lire sur la machine S) :

 
Sélectionnez
------------------------------------------------------------
Server listening on TCP port 80
TCP window size: 56.0 KByte (default)
------------------------------------------------------------
[ 6] local 192.168.29.1 port 5001 connected with 192.168.29.157 port 54334
[ 6] 0.0-10.0 sec 112 MBytes 93.7 Mbits/sec

Voici donc quelques exemples d'utilisation d'Iperf, si vous en avez d'autres, les commentaires sont ouverts !

3. Utilisation avancée de Iperf

3-1. Changement de la taille des buffers

Par défaut, les buffers d'écriture et de lecture sont de 8 000 octets. On peut utiliser la fonction '-l' pour modifier cette taille (taille minimum : 12 octets).

Par exemple, pour générer des paquets UDP (mais cela fonctionne aussi avec le protocole TCP) avec des buffers (in/out) de 40 octets.

Serveur :

 
Sélectionnez
# iperf -s -u -l 40

Client :

 
Sélectionnez
# iperf -c <adresse IP client> -u -l 40

Remarque : cela a pour effet de produire sur le réseau des paquets UDP de 40 octets (en-tête UDp inclus), ce qui correspond à la moyenne de la taille des paquets utilisés avec les protocoles de VoIP de type SIP ou H.323).

3-2. Afficher la taille du MTU

Il est parfois utile de connaître la taille du MTU sur un chemin réseau (par exemple pour personnaliser son stack IP en fonction de sa connexion Internet). Iperf permet, grâce à l'option '-m', d'afficher cette valeur dans le rapport.

Serveur :

 
Sélectionnez
# iperf -s -m

Client :

 
Sélectionnez
# iperf -c <adresse IP client> -m
 
Sélectionnez
------------------------------------------------------------
Client connecting to 192.168.29.1, TCP port 5001
TCP window size: 65.0 KByte (default)
------------------------------------------------------------
[ 3] local 192.168.29.157 port 51850 connected with 192.168.29.1 port 5001
[ ID] Interval Transfer Bandwidth
[ 3] 0.0-10.0 sec 111 MBytes 93.0 Mbits/sec
[ 3] MSS size 1448 bytes (MTU 1500 bytes, ethernet)

Il est alors possible de tester le réseau en fixant cette valeur avec l'option '-M' :

Serveur :

 
Sélectionnez
# iperf -s -M 40

Client :

 
Sélectionnez
# iperf -c <adresse IP client> -M 40

3-3. Faire un test bidirectionnel en UDP

Par défaut, lorsque l'on utilise le protocole UDP (option '-u'), les flux vont du client vers le serveur. Pour faire un test bidirectionnel (c'est-à-dire avec deux flux simultanés, client->serveur et serveur->client), il suffit d'utiliser l'option '-d' au niveau du client. Si vous souhaitez que ce test se fasse de manière non simultanée, il faut utiliser l'option '-r' en lieu et place de l'option '-d'.

 
Sélectionnez
# iperf -s -u

Client :

 
Sélectionnez
# iperf -c <adresse client> -u -d
... Client report:
[ 5] 0.0-10.0 sec 1.25 MBytes 1.05 Mbits/sec 13.697 ms 0/ 893 (0%)
[ 7] Server Report:
[ 7] 0.0-10.0 sec 1.25 MBytes 1.05 Mbits/sec 0.027 ms 0/ 891 (0%)

3-4. Faire un test avec plusieurs flux

Si vous souhaitez que Iperf génère non pas un seul flux réseau entre le client et le serveur, mais plusieurs. Il faut fixer le nombre avec l'option '-P'. Par exemple pour générer cinq flux UDP simultanés entre le client et le serveur, il faut utiliser les commandes suivantes :

Serveur :

 
Sélectionnez
# iperf -s -u

Client :

 
Sélectionnez
# iperf -c <adresse IP client> -u -P 5

3-5. Taguer le champ Diffserv

Si votre réseau est compatible avec la QoS Diffserv, vous pouvez taguer le champ DSCP des paquets générés par Iperf  en utilisant l'option -S :

 
Sélectionnez
# iperf -c <adresse IP client> -u -S 0x99

3-6. Changer le port d'écoute par défaut

Par défaut, le port d'écoute du serveur est le 5001 (UDP ou TCP). Pour le modifier (par exemple si vous devez traverser un Firewall ou vous n'avez pas la main, il faut utiliser l'option '-p' sur le serveur et le client.

Par exemple pour utiliser le port HTTP (80) :

Serveur :

 
Sélectionnez
# iperf -s -p 80

Client :

 
Sélectionnez
# iperf -c <adresse IP client> -p 80

4. IperfiT, un petit script pour les fans de Iperf

J'utilise actuellement Iperf (voir la liste des articles sur le sujet ici) dans le cadre de tests de performances de réseaux divers et variés. Bien que très simple à utiliser pour une personne avertie, Iperf n'est pas conçu pour automatiser des benchs en faisant varier les cibles et les paramètres.

J'ai donc développé, sous licence LGPL, un script Perl nommé IperfiT qui fait grosso modo les choses suivantes lors d'un test entre les machines A (sur lequel le script sera lancé) et B (qui se trouve de l'autre côté du réseau à tester et qui accepte les connexions SSH venant de A) :

  • test de la connectivité avec la machine B (A ping B) ;
  • connexion automatiquement en SSH vers la machine B ;
  • lancement du serveur IPerf sur la machine B ;
  • lancement du client sur la machine A ;
  • affichage du rapport venant de l'IPerf de la machine B ;
  • arrêt de l'Iperf de la machine B.

Les options de la version 0.1 de IperfiT sont les suivantes :

 
Sélectionnez
-h: Print the command line help
-v: Print the program version
-q: Quiet mode (no display)
-s <ip>: Server IP address
-n <user>: SSH user name used to connect to the server
-u: Use UDP protocol (default is TCP)
-b: Target bitrate for UDP flow
-t <time>: Test duration, default is 30 sec
-m <mss>: Set the TCP Maximum Segment Size (MTU-40), default 1400 bytes
-w <wsize>: Set the TCP Window Size, default 128 Kbytes
-l <bsize>: Set the R/W Buffer Size, default 8000 bytes
-d <tos>: Set the TOS field (Diffserv), default is 0

4-1. Installation de IperfiT

C'est assez simple, je l'ai mis à disposition dans ce répertoire. Vous pouvez également suivre cette procédure :

 
Sélectionnez
cd /tmp
wget http://svn.nicolargo.com/iperfit/trunk/iperfit.pl
chmod a+rx /tmp/iperfit.pl
cp /tmp/iperfit.pl /usr/local/bin

4-2. Utilisation de IperfiT en quelques exemples

Pour un simple test TCP de cinq minutes (300 secondes) vers la machine 192.168.0.100 (login SSH nicolargo) avec une taille MSS de 1200 octets :

 
Sélectionnez
iperfit.pl -c 192.168.0.100 -n nicolargo -t 300 -m 1200

Pour lancer un test entre votre machine et la machine d'adresse IP 192.168.0.100 (login SSH nicolargo) en UDP avec une taille de buffer de 170 octets sur une durée de 60 secondes et avec un débit de 64 kb/s, il suffit de saisir la ligne suivante :

 
Sélectionnez
iperfit.pl -c 192.168.0.100 -n nicolargo -u -l 170 -t 60 -b 64

4-3. Remarque

Si vous avez le message suivant au lancement du programme :

 
Sélectionnez
Can't locate Net/IPv4Addr.pm in @INC (@INC contains: /etc/perl /usr/local/lib/perl/5.10.1 /usr/local/share/perl/5.10.1 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.10 /usr/share/perl/5.10 /usr/local/lib/site_perl .) at ./iperfit.pl line 33.BEGIN failed--compilation aborted at ./iperfit.pl line 33.

C'est que vous n'avez pas la bibliothèque Perl IPv4Addr qui est installée, sous Ubuntu/Debian pour remédier à cela il faut saisir la commande suivante :

 
Sélectionnez
sudo aptitude install libnetwork-ipv4addr-perl

Si vous avez des améliorations à proposer à ce script, je suis à votre écoute !

5. XJperf une interface Java pour Iperf

Si vous utilisez Iperf pour calculer les performances de votre réseau, le programme XJperf vous intéressera sûrement. Reprenant une interface existante (Jperf), l'auteur du programme a considérablement amélioré les fonctionnalités et la stabilité de cette interface utilisateur.

Image non disponible

XJperf permet donc de prendre en main très rapidement l'application Iperf, sans avoir à en connaître par cœur les (nombreuses) options. C'est un moyen idéal pour connaître la bande passante, le délai de transit et la gigue entre deux équipements réseau.

6. Remerciements Developpez

L'équipe Réseaux remercie nicolargo pour la rédaction de ce tutoriel.

Nos remerciements à ClaudeLELOUP pour sa relecture orthographique.

N'hésitez pas à commenter cet article ! Commentez Donner une note à l'article (5)